{"id":37227840,"url":"https://github.com/zeriyoshi/libpoporon","last_synced_at":"2026-03-06T08:12:24.445Z","repository":{"id":331689236,"uuid":"1124773570","full_name":"zeriyoshi/libpoporon","owner":"zeriyoshi","description":"Reed-Solomon, LDPC, BCH, RNG implementation, written in C99","archived":false,"fork":false,"pushed_at":"2026-02-25T07:57:04.000Z","size":103,"stargazers_count":0,"open_issues_count":1,"forks_count":0,"subscribers_count":0,"default_branch":"main","last_synced_at":"2026-02-25T12:44:07.316Z","etag":null,"topics":["bch","c99","ldpc","reed-solomon","rng"],"latest_commit_sha":null,"homepage":"https://zeriyoshi.github.io/libpoporon/","language":"C","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/zeriyoshi.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null}},"created_at":"2025-12-29T15:37:08.000Z","updated_at":"2026-02-25T07:57:08.000Z","dependencies_parsed_at":null,"dependency_job_id":null,"html_url":"https://github.com/zeriyoshi/libpoporon","commit_stats":null,"previous_names":["zeriyoshi/libpoporon"],"tags_count":18,"template":false,"template_full_name":null,"purl":"pkg:github/zeriyoshi/libpoporon","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/zeriyoshi%2Flibpoporon","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/zeriyoshi%2Flibpoporon/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/zeriyoshi%2Flibpoporon/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/zeriyoshi%2Flibpoporon/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/zeriyoshi","download_url":"https://codeload.github.com/zeriyoshi/libpoporon/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/zeriyoshi%2Flibpoporon/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":30167089,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-03-06T07:56:45.623Z","status":"ssl_error","status_checked_at":"2026-03-06T07:55:55.621Z","response_time":250,"last_error":"SSL_connect returned=1 errno=0 peeraddr=140.82.121.6:443 state=error: unexpected eof while reading","robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":false,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["bch","c99","ldpc","reed-solomon","rng"],"created_at":"2026-01-15T03:24:21.699Z","updated_at":"2026-03-06T08:12:24.433Z","avatar_url":"https://github.com/zeriyoshi.png","language":"C","funding_links":[],"categories":[],"sub_categories":[],"readme":"# libpoporon\n\n[![CI](https://github.com/zeriyoshi/libpoporon/actions/workflows/ci.yaml/badge.svg)](https://github.com/zeriyoshi/libpoporon/actions/workflows/ci.yaml)\n[![License: BSD-3-Clause](https://img.shields.io/badge/license-BSD--3--Clause-02B36C)](https://opensource.org/license/bsd-3-clause)\n\n**Polynomial Operations Providing Optimal Reed-Solomon Organized Numerics**\n\n[🇯🇵 日本語版 README はこちら](README_ja.md)\n\nlibpoporon is a lightweight, high-performance forward error correction (FEC) library written in C99. It provides multiple error correction algorithms including Reed-Solomon, BCH, and LDPC codes, with optional SIMD acceleration for maximum performance.\n\n## Features\n\n- **Pure C99 Implementation** - No external dependencies, portable across platforms\n- **Multiple FEC Algorithms** - Reed-Solomon, BCH (Bose-Chaudhuri-Hocquenghem), and LDPC (Low-Density Parity-Check) codes\n- **SIMD Acceleration** - Automatic optimization using AVX2 (x86_64), NEON (ARM64), or WASM SIMD128\n- **Erasure Decoding** - Support for Reed-Solomon error correction with known error positions\n- **Soft Decision Decoding** - LDPC supports both hard and soft decision decoding with LLR input\n- **Burst Error Resistance** - LDPC includes interleaver support for improved burst error correction\n- **WebAssembly Support** - Can be compiled to WASM using Emscripten\n- **Memory Safe** - Carefully designed API with proper resource management\n- **Extensive Testing** - Comprehensive test suite with sanitizer and Valgrind support\n\n## Quick Start\n\n### Building\n\n```bash\n# Clone the repository\ngit clone https://github.com/zeriyoshi/libpoporon.git\ncd libpoporon\n\n# Build with CMake\ncmake -B build -DCMAKE_BUILD_TYPE=Release\ncmake --build build\n```\n\n### Build Options\n\n| Option | Default | Description |\n|--------|---------|-------------|\n| `POPORON_USE_SIMD` | `ON` | Enable SIMD optimizations |\n| `POPORON_USE_TESTS` | `OFF` | Build test suite |\n| `POPORON_USE_VALGRIND` | `OFF` | Enable Valgrind memory checking |\n| `POPORON_USE_COVERAGE` | `OFF` | Enable code coverage |\n| `POPORON_USE_ASAN` | `OFF` | Enable AddressSanitizer |\n| `POPORON_USE_MSAN` | `OFF` | Enable MemorySanitizer |\n| `POPORON_USE_UBSAN` | `OFF` | Enable UndefinedBehaviorSanitizer |\n\n### Running Tests\n\n```bash\ngit submodule update --init --recursive\ncmake -B build -DCMAKE_BUILD_TYPE=Debug -DPOPORON_USE_TESTS=ON\ncmake --build build\nctest --test-dir build --output-on-failure\n```\n\n## Usage Examples\n\n### Reed-Solomon Encoding and Decoding\n\n```c\n#include \u003cpoporon.h\u003e\n#include \u003cstdio.h\u003e\n#include \u003cstring.h\u003e\n\nint main(void) {\n    // RS(255, 223) - 32 parity symbols, can correct up to 16 errors\n    poporon_config_t *config = poporon_config_rs_default();\n    poporon_t *pprn = poporon_create(config);\n    if (!pprn) {\n        fprintf(stderr, \"Failed to create poporon instance\\n\");\n        poporon_config_destroy(config);\n        return 1;\n    }\n\n    // Prepare data\n    uint8_t data[64];\n    uint8_t parity[32];\n    memset(data, 0, sizeof(data));\n    memcpy(data, \"Hello, Reed-Solomon!\", 20);\n\n    // Encode - generate parity\n    poporon_encode(pprn, data, sizeof(data), parity);\n\n    // Simulate errors\n    data[0] ^= 0xFF;\n    data[10] ^= 0xAA;\n\n    // Decode - correct errors\n    size_t corrected_num = 0;\n    if (poporon_decode(pprn, data, sizeof(data), parity, \u0026corrected_num)) {\n        printf(\"Corrected %zu errors\\n\", corrected_num);\n        printf(\"Decoded: %s\\n\", data);\n    }\n\n    poporon_destroy(pprn);\n    poporon_config_destroy(config);\n    return 0;\n}\n```\n\n### BCH Encoding and Decoding\n\n```c\n#include \u003cpoporon.h\u003e\n#include \u003cstdio.h\u003e\n\nint main(void) {\n    // Create BCH(15, 5) with t=3 error correction capability\n    poporon_config_t *config = poporon_config_bch_default();\n    poporon_t *pprn = poporon_create(config);\n    if (!pprn) {\n        fprintf(stderr, \"Failed to create BCH instance\\n\");\n        poporon_config_destroy(config);\n        return 1;\n    }\n\n    printf(\"FEC type: %d\\n\", poporon_get_fec_type(pprn));\n    printf(\"Parity size: %zu bytes\\n\", poporon_get_parity_size(pprn));\n    printf(\"Info size: %zu bytes\\n\", poporon_get_info_size(pprn));\n\n    // Encode data\n    uint8_t data[1] = {21};\n    uint8_t parity[4];\n    poporon_encode(pprn, data, 1, parity);\n\n    // Simulate bit errors in data\n    data[0] ^= 0x0A;\n\n    // Decode and correct\n    size_t corrected = 0;\n    if (poporon_decode(pprn, data, 1, parity, \u0026corrected)) {\n        printf(\"Corrected %zu errors\\n\", corrected);\n        printf(\"Recovered data: %u\\n\", data[0]);\n    }\n\n    poporon_destroy(pprn);\n    poporon_config_destroy(config);\n    return 0;\n}\n```\n\n### LDPC Encoding and Decoding\n\n```c\n#include \u003cpoporon.h\u003e\n#include \u003cstdio.h\u003e\n#include \u003cstring.h\u003e\n\nint main(void) {\n    // Create LDPC encoder with rate 1/2 (100% redundancy)\n    poporon_config_t *config = poporon_config_ldpc_default(128, PPRN_LDPC_RATE_1_2);\n    poporon_t *pprn = poporon_create(config);\n    if (!pprn) {\n        fprintf(stderr, \"Failed to create LDPC instance\\n\");\n        poporon_config_destroy(config);\n        return 1;\n    }\n\n    size_t info_size = poporon_get_info_size(pprn);\n    size_t parity_size = poporon_get_parity_size(pprn);\n\n    printf(\"Info size: %zu bytes\\n\", info_size);\n    printf(\"Parity size: %zu bytes\\n\", parity_size);\n\n    // Prepare buffers\n    uint8_t *data = malloc(info_size);\n    uint8_t *parity = malloc(parity_size);\n\n    // Initialize data\n    for (size_t i = 0; i \u003c info_size; i++) {\n        data[i] = (uint8_t)(i * 17 + 23);\n    }\n\n    // Encode\n    poporon_encode(pprn, data, 128, parity);\n\n    // Simulate errors\n    data[0] ^= 0x01;\n    data[10] ^= 0x80;\n    data[20] ^= 0x40;\n\n    // Decode with iterative belief propagation\n    size_t corrected = 0;\n    if (poporon_decode(pprn, data, 128, parity, \u0026corrected)) {\n        uint32_t iterations = poporon_get_iterations_used(pprn);\n        printf(\"Decoded successfully in %u iterations\\n\", iterations);\n    }\n\n    free(data);\n    free(parity);\n    poporon_destroy(pprn);\n    poporon_config_destroy(config);\n    return 0;\n}\n```\n\n### LDPC with Burst Error Resistance\n\n```c\n#include \u003cpoporon.h\u003e\n#include \u003cstdio.h\u003e\n#include \u003cstring.h\u003e\n\nint main(void) {\n    // Create burst-resistant LDPC with a single convenience function\n    poporon_config_t *config = poporon_config_ldpc_burst_resistant(128, PPRN_LDPC_RATE_1_2);\n    poporon_t *pprn = poporon_create(config);\n\n    size_t info_size = poporon_get_info_size(pprn);\n    size_t parity_size = poporon_get_parity_size(pprn);\n\n    uint8_t *data = malloc(info_size);\n    uint8_t *parity = malloc(parity_size);\n\n    // Initialize and encode\n    for (size_t i = 0; i \u003c info_size; i++) {\n        data[i] = (uint8_t)i;\n    }\n    poporon_encode(pprn, data, 128, parity);\n\n    // Simulate burst error (consecutive bytes corrupted)\n    for (size_t i = 10; i \u003c 14; i++) {\n        data[i] ^= 0xFF;\n    }\n\n    // Decode — interleaving/deinterleaving is handled automatically\n    size_t corrected = 0;\n    if (poporon_decode(pprn, data, 128, parity, \u0026corrected)) {\n        uint32_t iterations = poporon_get_iterations_used(pprn);\n        printf(\"Burst error corrected in %u iterations\\n\", iterations);\n    }\n\n    free(data);\n    free(parity);\n    poporon_destroy(pprn);\n    poporon_config_destroy(config);\n    return 0;\n}\n```\n\n### Random Number Generator\n\n```c\n#include \u003cpoporon/rng.h\u003e\n#include \u003cstdio.h\u003e\n\nint main(void) {\n    // Create Xoshiro128++ RNG with seed\n    uint32_t seed = 12345;\n    poporon_rng_t *rng = poporon_rng_create(XOSHIRO128PP, \u0026seed, sizeof(seed));\n\n    // Generate random bytes\n    uint8_t buffer[16];\n    poporon_rng_next(rng, buffer, sizeof(buffer));\n\n    printf(\"Random bytes: \");\n    for (size_t i = 0; i \u003c sizeof(buffer); i++) {\n        printf(\"%02X \", buffer[i]);\n    }\n    printf(\"\\n\");\n\n    poporon_rng_destroy(rng);\n    return 0;\n}\n```\n\n## API Reference\n\n### Core Types\n\n```c\ntypedef struct _poporon_t poporon_t;                 // Unified FEC codec handle\ntypedef struct _poporon_config_t poporon_config_t;   // Opaque configuration object\ntypedef struct _poporon_erasure_t poporon_erasure_t; // Erasure position tracking\ntypedef struct _poporon_gf_t poporon_gf_t;           // Galois Field operations\ntypedef uint32_t poporon_buildtime_t;\n\n// FEC algorithm type\ntypedef enum {\n    PPLN_FEC_RS      = 1,    // Reed-Solomon\n    PPLN_FEC_LDPC    = 2,    // Low-Density Parity-Check\n    PPLN_FEC_BCH     = 3,    // Bose-Chaudhuri-Hocquenghem\n    PPLN_FEC_UNKNOWN = 255,\n} poporon_fec_type_t;\n```\n\n### LDPC Types and Constants\n\n```c\n// Code rates\ntypedef enum {\n    PPRN_LDPC_RATE_1_3,  // 200% redundancy\n    PPRN_LDPC_RATE_1_2,  // 100% redundancy\n    PPRN_LDPC_RATE_2_3,  // 50% redundancy\n    PPRN_LDPC_RATE_3_4,  // 33% redundancy\n    PPRN_LDPC_RATE_4_5,  // 25% redundancy\n    PPRN_LDPC_RATE_5_6,  // 20% redundancy\n} poporon_ldpc_rate_t;\n\n// Matrix construction types\ntypedef enum {\n    PPRN_LDPC_RANDOM,     // Random parity check matrix\n    PPRN_LDPC_QC_RANDOM,  // Quasi-Cyclic with random shifts\n} poporon_ldpc_matrix_type_t;\n```\n\n### Configuration Functions\n\n```c\n// Reed-Solomon configuration\npoporon_config_t *poporon_rs_config_create(uint8_t symbol_size, uint16_t generator_polynomial,\n                                           uint16_t first_consecutive_root, uint16_t primitive_element,\n                                           uint8_t num_roots, poporon_erasure_t *erasure,\n                                           uint16_t *syndrome);\npoporon_config_t *poporon_config_rs_default(void);  // RS(255, 223), 32 parity symbols\n\n// LDPC configuration\npoporon_config_t *poporon_ldpc_config_create(size_t block_size, poporon_ldpc_rate_t rate,\n                                             poporon_ldpc_matrix_type_t matrix_type,\n                                             uint32_t column_weight, bool use_soft_decode,\n                                             bool use_outer_interleave, bool use_inner_interleave,\n                                             uint32_t interleave_depth, uint32_t lifting_factor,\n                                             uint32_t max_iterations, const int8_t *soft_llr,\n                                             size_t soft_llr_size, uint64_t seed);\npoporon_config_t *poporon_config_ldpc_default(size_t block_size, poporon_ldpc_rate_t rate);\npoporon_config_t *poporon_config_ldpc_burst_resistant(size_t block_size, poporon_ldpc_rate_t rate);\n\n// BCH configuration\npoporon_config_t *poporon_bch_config_create(uint8_t symbol_size, uint16_t generator_polynomial,\n                                            uint8_t correction_capability);\npoporon_config_t *poporon_config_bch_default(void);  // BCH(15, 5), t=3\n\n// Destroy configuration (safe to call after poporon_create)\nvoid poporon_config_destroy(poporon_config_t *config);\n```\n\n### Codec Functions\n\n```c\n// Create/destroy codec\npoporon_t *poporon_create(const poporon_config_t *config);\nvoid poporon_destroy(poporon_t *pprn);\n\n// Encode data\nbool poporon_encode(poporon_t *pprn, uint8_t *data, size_t size, uint8_t *parity);\n\n// Decode data\nbool poporon_decode(poporon_t *pprn, uint8_t *data, size_t size,\n                    uint8_t *parity, size_t *corrected_num);\n```\n\n### Query Functions\n\n```c\npoporon_fec_type_t poporon_get_fec_type(const poporon_t *pprn);\nsize_t poporon_get_parity_size(const poporon_t *pprn);\nsize_t poporon_get_info_size(const poporon_t *pprn);\nuint32_t poporon_get_iterations_used(const poporon_t *pprn);  // LDPC only (0 for RS/BCH)\n```\n\n### Utility Functions\n\n```c\nuint32_t poporon_version_id(void);\npoporon_buildtime_t poporon_buildtime(void);\n```\n\n### Erasure API\n\n```c\npoporon_erasure_t *poporon_erasure_create(uint16_t num_roots, uint32_t initial_capacity);\npoporon_erasure_t *poporon_erasure_create_from_positions(uint16_t num_roots,\n                                                         const uint32_t *erasure_positions,\n                                                         uint32_t erasure_count);\nbool poporon_erasure_add_position(poporon_erasure_t *erasure, uint32_t position);\nvoid poporon_erasure_reset(poporon_erasure_t *erasure);\nvoid poporon_erasure_destroy(poporon_erasure_t *eras);\n```\n\n### Galois Field API\n\n```c\npoporon_gf_t *poporon_gf_create(uint8_t symbol_size, uint16_t generator_polynomial);\nvoid poporon_gf_destroy(poporon_gf_t *gf);\n```\n\n### RNG API\n\n```c\ntypedef enum {\n    XOSHIRO128PP  // Xoshiro128++ algorithm\n} poporon_rng_type_t;\n\npoporon_rng_t *poporon_rng_create(poporon_rng_type_t type, void *seed, size_t seed_size);\nvoid poporon_rng_destroy(poporon_rng_t *rng);\nbool poporon_rng_next(poporon_rng_t *rng, void *dest, size_t size);\n```\n\n## Algorithm Comparison\n\n| Algorithm | Type | Best For | Correction Capability |\n|-----------|------|----------|----------------------|\n| Reed-Solomon | Block code | Burst errors, storage | Up to `num_roots/2` symbol errors |\n| BCH | Binary block code | Random bit errors | Up to `t` bit errors |\n| LDPC | Sparse graph code | Near Shannon limit, soft decoding | Iterative, depends on rate |\n\n## Common Configurations\n\n### Reed-Solomon\n\n| Name | Parameters | Correction |\n|------|------------|------------|\n| RS(255, 223) | symbol_size=8, gen_poly=0x11D, num_roots=32 | 16 symbols |\n| RS(255, 239) | symbol_size=8, gen_poly=0x11D, num_roots=16 | 8 symbols |\n| RS(255, 247) | symbol_size=8, gen_poly=0x11D, num_roots=8 | 4 symbols |\n\n### BCH\n\n| Name | Parameters | Correction |\n|------|------------|------------|\n| BCH(15, 5) | symbol_size=4, gen_poly=0x13, t=3 | 3 bits |\n| BCH(31, 21) | symbol_size=5, gen_poly=0x25, t=2 | 2 bits |\n| BCH(63, 51) | symbol_size=6, gen_poly=0x43, t=2 | 2 bits |\n\n### LDPC\n\n| Rate | Redundancy | Block Sizes |\n|------|------------|-------------|\n| 1/3 | 200% | 32 - 8192 bytes |\n| 1/2 | 100% | 32 - 8192 bytes |\n| 2/3 | 50% | 32 - 8192 bytes |\n| 3/4 | 33% | 32 - 8192 bytes |\n| 4/5 | 25% | 32 - 8192 bytes |\n| 5/6 | 20% | 32 - 8192 bytes |\n\n## SIMD Support\n\nThe library automatically detects and enables SIMD optimizations based on the target architecture:\n\n| Platform | SIMD | Status |\n|----------|------|--------|\n| Linux x86_64 | AVX2 | ✅ Fully supported |\n| Linux ARM64 | NEON | ✅ Fully supported |\n| Linux i386 | None | ✅ Supported (scalar) |\n| Linux s390x | None | ✅ Supported (scalar) |\n| macOS x86_64 | AVX2 | ✅ Fully supported |\n| macOS ARM64 | NEON | ✅ Fully supported |\n| Windows x86_64 | AVX2 | ✅ Fully supported |\n| WebAssembly | SIMD128 | ✅ Fully supported |\n\nTo disable SIMD optimizations:\n```bash\ncmake -B build -DPOPORON_USE_SIMD=OFF\n```\n\n## Code Coverage\n\nTo generate coverage reports (requires GCC, `lcov`, and `genhtml`):\n\n```bash\ncmake -B build -DCMAKE_BUILD_TYPE=Debug \\\n               -DPOPORON_USE_TESTS=ON \\\n               -DPOPORON_USE_COVERAGE=ON\ncmake --build build\nctest --test-dir build --output-on-failure\n```\n\n## Integration\n\n### Using CMake `add_subdirectory`\n\nAdd libpoporon as a subdirectory in your project:\n\n```cmake\nadd_subdirectory(path/to/libpoporon)\ntarget_link_libraries(your_target PRIVATE poporon)\n```\n\n### Manual Integration\n\nInclude the headers and link the static library:\n\n```cmake\ntarget_include_directories(your_target PRIVATE path/to/libpoporon/include)\ntarget_link_libraries(your_target PRIVATE path/to/libpoporon/build/libpoporon.a)\n```\n\n## Project Structure\n\n```\nlibpoporon/\n├── include/\n│   ├── poporon.h          # Main public header (unified API)\n│   └── poporon/\n│       ├── erasure.h      # Erasure API\n│       ├── gf.h           # Galois Field API\n│       └── rng.h          # Random number generator API\n├── src/\n│   ├── bch.c              # BCH implementation\n│   ├── encode.c           # Encoding implementation\n│   ├── decode.c           # Decoding with Berlekamp-Massey\n│   ├── erasure.c          # Erasure handling\n│   ├── gf.c               # Galois Field implementation\n│   ├── ldpc.c             # LDPC implementation\n│   ├── rng.c              # Xoshiro128++ RNG\n│   ├── rs.c               # Reed-Solomon core\n│   ├── poporon.c          # Unified API implementation\n│   └── internal/\n│       ├── common.h       # Internal types and macros\n│       ├── config.h       # Configuration internals\n│       ├── ldpc.h         # LDPC internal structures\n│       ├── polynomial.h   # Polynomial arithmetic internals\n│       ├── rs.h           # Reed-Solomon internal structures\n│       └── simd.h         # SIMD abstractions\n├── tests/                 # Test suite using Unity\n│   ├── test_basic.c       # Basic functionality tests\n│   ├── test_bch.c         # BCH tests\n│   ├── test_codec.c       # Codec tests\n│   ├── test_erasure.c     # Erasure tests\n│   ├── test_gf.c          # Galois Field tests\n│   ├── test_invalid.c     # Invalid input tests\n│   ├── test_ldpc.c        # LDPC tests\n│   ├── test_rng.c         # RNG tests\n│   ├── test_rs.c          # Reed-Solomon tests\n│   ├── test_unified.c     # Unified API tests\n│   ├── fec_compat.c       # FEC compatibility tests\n│   └── util.h             # Test utilities\n├── cmake/                 # CMake modules\n│   ├── buildtime.cmake    # Build timestamp\n│   ├── emscripten.cmake   # WebAssembly support\n│   └── test.cmake         # Test configuration\n└── third_party/           # Dependencies\n    ├── emsdk/             # Emscripten SDK (optional)\n    ├── unity/             # Unity Test framework\n    └── valgrind/          # Valgrind headers\n```\n\n## Dependencies\n\n- **[Unity](https://github.com/ThrowTheSwitch/Unity)** - Unit testing framework (submodule, tests only)\n\n## License\n\nBSD-3-Clause - see [LICENSE](LICENSE) for details.\n\n## Author\n\n**Go Kudo** ([@zeriyoshi](https://github.com/zeriyoshi)) - [zeriyoshi@gmail.com](mailto:zeriyoshi@gmail.com)\n\nThis library contains an implementation based on the Reed-Solomon implementation from [`libcorrect`](https://github.com/quiet/libcorrect) . The original author of this implementation is **Brian Armstrong.**\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fzeriyoshi%2Flibpoporon","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fzeriyoshi%2Flibpoporon","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fzeriyoshi%2Flibpoporon/lists"}