flashalign 0.1.0__tar.gz

flashalign-0.1.0/.gitignore

@@ -0,0 +1,7 @@
+build/
+build-*/
+dist/
+*.egg-info/
+__pycache__/
+*.so
+.venv/

flashalign-0.1.0/CMakeLists.txt

@@ -0,0 +1,215 @@
+cmake_minimum_required(VERSION 3.18)
+
+# The release version is read from pyproject.toml, which must hold exactly one.
+file(STRINGS "${CMAKE_CURRENT_LIST_DIR}/pyproject.toml" FA_VERSION_LINES
+    REGEX "^version = \"[0-9.]+\"$")
+list(LENGTH FA_VERSION_LINES FA_VERSION_LINE_COUNT)
+if(NOT FA_VERSION_LINE_COUNT EQUAL 1)
+    message(FATAL_ERROR
+        "pyproject.toml must contain exactly one numeric project version")
+endif()
+string(REGEX REPLACE "^version = \"([0-9.]+)\"$" "\\1"
+    FA_PROJECT_VERSION "${FA_VERSION_LINES}")
+
+project(FlashAlign VERSION "${FA_PROJECT_VERSION}" LANGUAGES C CXX)
+
+include(GNUInstallDirs)
+include(CMakePackageConfigHelpers)
+
+include_directories("${CMAKE_CURRENT_SOURCE_DIR}/include")
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+# Version headers: cmake/GenerateVersion.cmake adds a "+g<sha>[.dirty]" suffix unless the tree
+# is the release tag. It runs at configure time and again on every build (fa_version).
+option(FLASHALIGN_VERSION_SUFFIX
+    "Append a git commit suffix (+g<sha>[.dirty]) to the reported version" ON)
+set(FA_GENERATED_INCLUDE_DIR ${CMAKE_CURRENT_BINARY_DIR}/generated)
+set(FA_GENERATE_VERSION_COMMAND
+    ${CMAKE_COMMAND}
+    -DFA_VERSION_BASE=${FA_PROJECT_VERSION}
+    -DFA_SOURCE_DIR=${CMAKE_CURRENT_SOURCE_DIR}
+    -DFA_VERSION_H_IN=${CMAKE_CURRENT_SOURCE_DIR}/csrc/version.h.in
+    -DFA_VERSION_H_OUT=${FA_GENERATED_INCLUDE_DIR}/fa_version.h
+    -DFA_VERSION_HPP_IN=${CMAKE_CURRENT_SOURCE_DIR}/include/flashalign/version.hpp.in
+    -DFA_VERSION_HPP_OUT=${FA_GENERATED_INCLUDE_DIR}/flashalign/version.hpp
+    -DFA_VERSION_SUFFIX=${FLASHALIGN_VERSION_SUFFIX}
+    -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/GenerateVersion.cmake)
+file(MAKE_DIRECTORY ${FA_GENERATED_INCLUDE_DIR}/flashalign)
+execute_process(COMMAND ${FA_GENERATE_VERSION_COMMAND}
+    RESULT_VARIABLE FA_GENERATE_VERSION_RC)
+if(NOT FA_GENERATE_VERSION_RC EQUAL 0)
+    message(FATAL_ERROR "failed to generate the version headers")
+endif()
+add_custom_target(fa_version ALL
+    COMMAND ${FA_GENERATE_VERSION_COMMAND}
+    COMMENT "Refreshing the generated version headers"
+    VERBATIM)
+
+
+include(cmake/Dependencies.cmake)
+
+# ksw2 DP kernels, adapted from minimap2 (ksw2_ll_sse.c unmodified). SSE4.1 on x86; on ARM
+# through the bundled sse2neon, with -fsigned-char because ksw2 assumes a signed char.
+set(KSW2_DIR ${CMAKE_CURRENT_SOURCE_DIR}/csrc/dp)
+set(KSW2_SOURCES
+    ${KSW2_DIR}/ksw2_extz2_sse.c
+    ${KSW2_DIR}/ksw2_extd2_sse.c
+    ${KSW2_DIR}/ksw2_exts2_sse.c
+    ${KSW2_DIR}/ksw2_ll_sse.c)
+if(CMAKE_SYSTEM_PROCESSOR MATCHES "^(aarch64|arm64|ARM64)$")
+    set_source_files_properties(${KSW2_SOURCES} PROPERTIES
+        COMPILE_OPTIONS "-DKSW_SSE2_ONLY;-D__SSE2__;-fsigned-char;-I${KSW2_DIR}/sse2neon")
+    message(STATUS "FlashAlign: ksw2 built for ARM/NEON via bundled sse2neon shim.")
+elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(x86_64|AMD64|amd64|i[3-6]86)$")
+    include(CheckCCompilerFlag)
+    check_c_compiler_flag("-msse4.1" FLASHALIGN_C_HAS_MSSE41)
+    if(NOT FLASHALIGN_C_HAS_MSSE41)
+        message(FATAL_ERROR
+            "The selected x86 C compiler does not support ksw2's -msse4.1 flag")
+    endif()
+    set_source_files_properties(${KSW2_SOURCES} PROPERTIES COMPILE_OPTIONS "-msse4.1")
+    message(STATUS "FlashAlign: ksw2 built for x86 via SSE4.1.")
+else()
+    message(FATAL_ERROR
+        "Unsupported ksw2 architecture: ${CMAKE_SYSTEM_PROCESSOR}")
+endif()
+
+# ksw2 and its arena allocator as one PIC object library with hidden symbols, shared by the
+# CLI and the Python module. -O3 whatever the build type.
+add_library(fa_ksw2 OBJECT ${KSW2_SOURCES} ${KSW2_DIR}/ksw_arena.c)
+target_include_directories(fa_ksw2 PRIVATE csrc)
+target_compile_options(fa_ksw2 PRIVATE -O3)
+set_target_properties(fa_ksw2 PROPERTIES
+    POSITION_INDEPENDENT_CODE ON
+    C_VISIBILITY_PRESET hidden)
+
+include(cmake/CompilerOptions.cmake)
+include(cmake/Modules.cmake)
+
+# The public C++ API, compiled once and linked into both the shared libflashalign and the
+# Python extension, so the wheel holds a single shared object.
+add_library(flashalign_public OBJECT csrc/api/public.cpp csrc/api/fastx.cpp)
+set_target_properties(flashalign_public PROPERTIES POSITION_INDEPENDENT_CODE ON)
+target_compile_features(flashalign_public PUBLIC cxx_std_17)
+target_include_directories(flashalign_public
+    PUBLIC
+      $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+      $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/generated>
+    PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/csrc)
+target_link_libraries(flashalign_public PUBLIC
+    flashalign_api flashalign_io)
+
+add_library(flashalign_library SHARED $<TARGET_OBJECTS:flashalign_public>)
+set_target_properties(flashalign_library PROPERTIES
+    OUTPUT_NAME flashalign
+    EXPORT_NAME flashalign)
+target_compile_features(flashalign_library PUBLIC cxx_std_17)
+target_include_directories(flashalign_library
+    PUBLIC
+      $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+      $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/generated>
+      $<INSTALL_INTERFACE:include>)
+target_link_libraries(flashalign_library PRIVATE
+    flashalign_api flashalign_io)
+add_library(FlashAlign::flashalign ALIAS flashalign_library)
+
+# The command-line tool.
+add_executable(flashalign
+    csrc/cli/main.cpp
+    csrc/cli/parse.cpp
+    csrc/cli/help.cpp
+    csrc/cli/option_registry.cpp
+    csrc/cli/align_command.cpp
+    csrc/cli/output_writer.cpp
+    csrc/cli/index_command.cpp
+    csrc/cli/report.cpp
+)
+target_include_directories(flashalign PRIVATE csrc ${FA_GENERATED_INCLUDE_DIR})
+# Both targets compile fa_version.h, which fa_version rewrites at build time.
+add_dependencies(flashalign fa_version)
+add_dependencies(flashalign_io fa_version)
+target_link_libraries(flashalign PRIVATE
+    flashalign_api flashalign_io)
+
+# The nanobind Python extension. pyproject.toml turns it on for `pip install .`.
+option(FLASHALIGN_BUILD_PYTHON "Build the nanobind Python extension (_flashalign)" OFF)
+if(FLASHALIGN_BUILD_PYTHON)
+    find_package(
+        Python 3.12 REQUIRED
+        COMPONENTS Interpreter Development.Module Development.SABIModule)
+    execute_process(
+        COMMAND "${Python_EXECUTABLE}" -c "import nanobind; print(nanobind.cmake_dir())"
+        OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE _nb_cmake_dir)
+    list(APPEND CMAKE_PREFIX_PATH "${_nb_cmake_dir}")
+    find_package(nanobind CONFIG REQUIRED)
+    # Stable ABI: one wheel per platform for Python 3.12+.
+    nanobind_add_module(
+        _flashalign STABLE_ABI NB_STATIC
+        csrc/python/module.cpp
+        csrc/python/bind_index.cpp
+        csrc/python/bind_config.cpp
+        csrc/python/bind_aligner.cpp
+        csrc/python/bind_alignment.cpp
+        csrc/python/bind_fastx.cpp)
+    target_include_directories(
+        _flashalign PRIVATE
+        ${CMAKE_CURRENT_SOURCE_DIR}/include
+        ${CMAKE_CURRENT_BINARY_DIR}/generated)
+    # Linked in statically rather than against libflashalign, which auditwheel cannot bundle.
+    target_link_libraries(_flashalign PRIVATE flashalign_public)
+    # module.cpp includes the generated flashalign/version.hpp.
+    add_dependencies(_flashalign fa_version)
+    # Export no zlib or engine symbols, so they cannot clash with another zlib loaded in the
+    # same interpreter.
+    set_target_properties(_flashalign PROPERTIES
+        C_VISIBILITY_PRESET hidden CXX_VISIBILITY_PRESET hidden VISIBILITY_INLINES_HIDDEN ON)
+    if(NOT APPLE AND NOT WIN32)
+        target_link_options(_flashalign PRIVATE -Wl,--exclude-libs,ALL)
+    endif()
+    install(
+        TARGETS _flashalign
+        LIBRARY DESTINATION flashalign COMPONENT Python)
+endif()
+
+install(TARGETS flashalign_library
+    EXPORT FlashAlignTargets
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT SharedLibrary
+    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT Development
+    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT SharedLibrary
+    INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+install(
+    TARGETS flashalign
+    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT CLI)
+install(FILES flashalign.1
+    DESTINATION ${CMAKE_INSTALL_MANDIR}/man1
+    COMPONENT CLI)
+install(DIRECTORY include/flashalign/
+    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/flashalign
+    COMPONENT Development
+    FILES_MATCHING PATTERN "*.hpp")
+install(FILES
+    "${CMAKE_CURRENT_BINARY_DIR}/generated/flashalign/version.hpp"
+    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/flashalign
+    COMPONENT Development)
+
+configure_package_config_file(
+    "${CMAKE_CURRENT_SOURCE_DIR}/cmake/FlashAlignConfig.cmake.in"
+    "${CMAKE_CURRENT_BINARY_DIR}/FlashAlignConfig.cmake"
+    INSTALL_DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/FlashAlign")
+write_basic_package_version_file(
+    "${CMAKE_CURRENT_BINARY_DIR}/FlashAlignConfigVersion.cmake"
+    VERSION "${PROJECT_VERSION}"
+    COMPATIBILITY SameMajorVersion)
+install(EXPORT FlashAlignTargets
+    FILE FlashAlignTargets.cmake
+    NAMESPACE FlashAlign::
+    DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/FlashAlign"
+    COMPONENT Development)
+install(FILES
+    "${CMAKE_CURRENT_BINARY_DIR}/FlashAlignConfig.cmake"
+    "${CMAKE_CURRENT_BINARY_DIR}/FlashAlignConfigVersion.cmake"
+    DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/FlashAlign"
+    COMPONENT Development)

flashalign-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026, Gong Chen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

flashalign-0.1.0/PKG-INFO

@@ -0,0 +1,245 @@
+Metadata-Version: 2.1
+Name: flashalign
+Version: 0.1.0
+Summary: CPU-native long-read aligner for DNA and spliced RNA, with a mappy-style Python API
+Keywords: aligner,bioinformatics,long-read,nanopore,pacbio,rna-seq,sequence-alignment,spliced-alignment,syncmer
+Author-Email: Gong Chen <dsbchen@ucdavis.edu>
+License: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: C++
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Project-URL: Homepage, https://github.com/97YearsOldProgrammer/flashalign
+Project-URL: Source, https://github.com/97YearsOldProgrammer/flashalign
+Project-URL: Issues, https://github.com/97YearsOldProgrammer/flashalign/issues
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# FlashAlign
+
+[![GitHub Downloads](https://img.shields.io/github/downloads/97YearsOldProgrammer/flashalign/total.svg?style=social&logo=github&label=Download)](https://github.com/97YearsOldProgrammer/flashalign/releases)
+[![PyPI](https://img.shields.io/pypi/v/flashalign.svg?style=flat)](https://pypi.org/project/flashalign/)
+[![PyPI Downloads](https://img.shields.io/pypi/dm/flashalign.svg?label=PyPI%20downloads)](https://pypi.org/project/flashalign/)
+[![License](https://img.shields.io/github/license/97YearsOldProgrammer/flashalign.svg)](LICENSE)
+
+## Getting started
+
+```sh
+git clone https://github.com/97YearsOldProgrammer/flashalign.git
+cd flashalign
+cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
+cmake --build build --target flashalign -j
+# long reads against a reference genome
+./build/flashalign align ref.fa reads.fq > aln.sam
+# create an index first and then map
+./build/flashalign index -x lr:hq ref.fa              # writes ref.fa.faix
+./build/flashalign align ref.fa.faix hifi.fq.gz > aln.sam
+# use presets
+./build/flashalign align -x lr ref.fa ont.fq.gz > aln.sam                 # Oxford Nanopore genomic reads
+./build/flashalign align -x lr:hq ref.fa hifi.fq.gz > aln.sam             # PacBio HiFi genomic reads
+./build/flashalign align -x splice ref.fa cdna.fq.gz > aln.sam            # spliced long reads (strand unknown)
+./build/flashalign align -x splice:hq -u f ref.fa isoseq.fq.gz > aln.sam  # PacBio Iso-Seq (transcript strand)
+./build/flashalign align -x splice --junc-bed anno.bed ref.fa cdna.fq.gz > aln.sam  # use annotated junctions
+# man page for detailed command line options
+man ./flashalign.1
+```
+
+## Users' guide
+
+### Installation
+
+For Linux x86-64, a precompiled binary is on the
+[release page](https://github.com/97YearsOldProgrammer/flashalign/releases). It runs on any
+x86-64 Linux with glibc 2.17 or newer and needs no installation:
+
+```sh
+curl -L https://github.com/97YearsOldProgrammer/flashalign/releases/download/v0.1.0/flashalign-0.1.0_x64-linux.tar.bz2 | tar -jxvf -
+./flashalign-0.1.0_x64-linux/flashalign version
+```
+
+The Python package (see the [Developers' guide](#developers-guide)) installs with pip. Prebuilt
+wheels cover Linux on x86-64 and ARM and macOS on Apple silicon, for Python 3.12 or newer:
+
+```sh
+pip install flashalign
+```
+
+Otherwise, FlashAlign is built from source with CMake 3.18 or newer, a C and C++17 compiler and
+zlib 1.2.9 or newer:
+
+```sh
+cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
+cmake --build build --target flashalign -j
+./build/flashalign version
+```
+
+The result is one binary, `build/flashalign`. The same commands build on x86-64, where the
+alignment kernels use SSE4.1, and on ARM, where they go through the bundled sse2neon shim.
+
+### General usage
+
+Without options, `flashalign align` takes a reference and a read file, maps under the `lr`
+preset and writes base-level alignments in the SAM format:
+
+```sh
+flashalign align ref.fa reads.fq > aln.sam
+```
+
+You can ask for PAF with the CIGAR in the `cg` tag:
+
+```sh
+flashalign align -f paf -c ref.fa reads.fq > aln.paf
+```
+
+Without `-c`, PAF output is placement only: no base-level alignment is done, so there is no
+CIGAR and the coordinates differ from those of the base-level alignment:
+
+```sh
+flashalign align -f paf ref.fa reads.fq > approx-mapping.paf
+```
+
+Reads may be FASTA or FASTQ, plain or gzip'd, and several read files may follow the reference.
+
+A FASTA reference is indexed in memory on every run. To index it once, write the index with
+`flashalign index` and give the index in place of the reference:
+
+```sh
+flashalign index -x lr:hq ref.fa                  # indexing; writes ref.fa.faix
+flashalign align ref.fa.faix reads.fq > aln.sam   # alignment
+```
+
+The index records the preset it was built with, and `align` maps under that preset unless `-x`
+is given. The index owns the seeding: `-k`, `-s` and `-I` are indexing options and can't be
+changed during mapping, and an explicit `-x` at mapping time keeps the index's own `-k` and
+`-s`. Keep one index per seeding: `lr` (`-k21 -s9`), `lr:hq` (`-k21 -s5`), and one index shared
+by `splice` and `splice:hq` (`-k15 -s10`).
+
+### Use cases
+
+FlashAlign is tuned to a read type with a preset, `-x`, which sets several options at the
+same time. The default is `lr`.
+
+#### Map long genomic reads
+
+```sh
+flashalign align -x lr ref.fa ont.fq.gz > aln.sam       # Oxford Nanopore reads
+flashalign align -x lr:hq ref.fa hifi.fq.gz > aln.sam   # PacBio HiFi reads
+```
+
+`lr` is for noisy long reads of ~10% error rate. `lr:hq` is for accurate long reads with an
+error rate below 1%; PacBio HiFi reads belong there, and there is no separate HiFi preset. The
+two differ in seeding (`-s9` and `-s5`) and in scoring.
+
+Seeds that occur too often in the reference are ignored. The cutoff follows the reference: it is
+the larger of 200 and the occurrence of the top 1.81e-4 fraction of the most frequent seeds in
+the index, at most 500 under `lr:hq`, and voting and chaining use the same number. On a human
+genome it is 200; on a repeat-rich genome such as wheat it is about 2,200 under `lr` and 500
+under `lr:hq`. `--max-vote-occ` sets it for both.
+
+#### Map long mRNA/cDNA reads
+
+```sh
+flashalign align -x splice ref.fa cdna.fq.gz > aln.sam            # Nanopore cDNA or direct RNA
+flashalign align -x splice:hq -u f ref.fa isoseq.fq.gz > aln.sam  # PacBio Iso-Seq
+```
+
+In the splice presets a long deletion is taken as an intron and written as the `N` CIGAR
+operator; `-G` sets the maximum intron length (200k by default). By default (`-u b`) the
+canonical GT-AG splice sites are looked for on both strands and the transcript strand is
+written to the `ts` tag; `-u f` looks on the transcript strand only, for reads that are already
+on that strand. `splice:hq` differs from `splice` only in scoring.
+
+FlashAlign can take annotated junctions and prefer them during base alignment:
+
+```sh
+paftools.js gff2bed anno.gtf > anno.bed
+flashalign align -x splice --junc-bed anno.bed ref.fa cdna.fq.gz > aln.sam
+```
+
+`--junc-bed` takes gene annotations in the 12-column BED format, which `paftools.js gff2bed`
+converts from GTF or GFF3, or intron positions in 6-column BED with the strand column. A splice
+donor or acceptor found in the annotation gets a score bonus, `--junc-bonus` (9 by default).
+
+### Output
+
+SAM is the default; `-f bam` writes BAM and `-f paf` writes PAF. Without `-f`, a `.sam`, `.bam`
+or `.paf` extension on `-o` selects the format:
+
+```sh
+flashalign align -x lr:hq ref.fa hifi.fq.gz -o aln.bam
+```
+
+Unmapped reads are written to SAM and BAM unless `--sam-hit-only` is given; PAF never carries
+them. Secondary alignments are written only with `--secondary yes`. `--cs`, `--MD` and `--eqx`
+add the `cs` tag, the `MD` tag and `=`/`X` CIGAR operators. The PAF columns, the tags and the
+`cs` operations are listed under OUTPUT FORMAT in the manual.
+
+### Advanced features
+
+#### The resolved configuration
+
+`--show-config` prints every resolved option with the source of its value, then exits without
+loading the reference or the reads; given an index, it reads only the index header:
+
+```sh
+flashalign align -x lr:hq --show-config
+flashalign align --show-config ref.fa.faix
+```
+
+#### Multi-part index
+
+`-I` caps the reference bases loaded into memory for indexing. A reference longer than that is
+indexed in parts of whole contigs, and `align` maps the reads against one part at a time,
+reading them once per part:
+
+```sh
+flashalign index -I 4G ref.fa
+flashalign align ref.fa.faix reads.fq > aln.sam
+```
+
+Mapping quality is incorrect given a multi-part index.
+
+### Getting help
+
+The manual page, [`flashalign.1`](flashalign.1), describes every option, the output format and
+the exit status (`man ./flashalign.1`). `flashalign align --help` and `flashalign index --help`
+list the common options. Bugs and questions go to the
+[issue page](https://github.com/97YearsOldProgrammer/flashalign/issues).
+
+### Citing FlashAlign
+
+The manuscript is not yet public. Until it is, cite the repository by URL and commit.
+
+## Developers' guide
+
+FlashAlign is also a C++ library, with its public headers in
+[`include/flashalign/`](include/flashalign/), and a Python package, `flashalign`, that drives
+the same library:
+
+```sh
+python -m pip install .
+python demo.py ref.fa reads.fq
+```
+
+The package needs CPython 3.12 or newer and installs no `flashalign` command.
+[`demo.py`](demo.py) shows typical use; `help(flashalign.Aligner)` and
+[`python/flashalign/_flashalign.pyi`](python/flashalign/_flashalign.pyi) document the API.
+
+## Limitations
+
+- Long reads only: a read has to carry enough anchors to be collapsed into one or more
+  diagonals.
+- FlashAlign requires SSE4.1 instructions on x86 CPUs or NEON on ARM CPUs. A build without
+  them is not provided.
+
+## License
+
+FlashAlign is released under the MIT License; see [`LICENSE`](LICENSE).
+[`THIRD_PARTY_NOTICES.md`](THIRD_PARTY_NOTICES.md) covers the third-party code.