libLogit

Install And Package Status

This page answers the question every developer asks first: “How do I get libLogit into my project right now, and how close is that install path to real Beta quality?”

What “Supported In Beta” Means

A binding counts as Beta-ready only when it has all of the following:

  1. A normal install path for that ecosystem.
  2. A public package identity and version story.
  3. A direct LOGIT example.
  4. A config-loaded example.
  5. Shared conformance evidence.
  6. Release verification evidence.
  7. Clear limitations when parity is still incomplete.

During Alpha, several bindings already have package metadata and build proof, but not all of them are yet at the “install it anywhere with full confidence” stage.

Current Install Routes

Language Today Beta target
Python python -m pip install -e . from this repo; wheel and sdist verification exist. pip install liblogit with published wheel/sdist and viewer command included.
C Build and install with CMake. find_package(libLogit CONFIG REQUIRED) and a stable installed header/library story.
C++ Build and install with CMake. Stable CMake package plus documented dependency handling for JSON/config loading.
C# Source tree and NuGet artifact inspection are present. Published NuGet package with smoke-tested install/consume workflow.
Java Source tree and Maven artifact inspection are present. Published Maven coordinates with verified consumer install path.
JavaScript npm metadata and installed-tarball smoke proof exist. Published npm package with a stable Node-first import story.
Go Go module source and tests exist. Stable module path, tagged releases, and starter docs.
Kotlin Kotlin facade builds against the Java artifact. Published companion package with stable install instructions.

Install Commands

Python

git clone https://github.com/asparks1987/libLogit.git
cd libLogit
python -m pip install -e .

For development and verification:

python -m pip install -e ".[dev]"

C And C++

cmake -S . -B build/liblogit -DCMAKE_BUILD_TYPE=Release
cmake --build build/liblogit
cmake --install build/liblogit --prefix /path/to/liblogit-install

Consumer CMake projects then use:

find_package(libLogit CONFIG REQUIRED)
target_link_libraries(my_app PRIVATE libLogit::c)
target_link_libraries(my_cpp_app PRIVATE libLogit::cpp)

JavaScript

Current repo-local usage:

const { LOGIT, levels } = require("../../languages/javascript/src/liblogit");

Beta target:

npm install @liblogit/liblogit

Go

Current source usage:

import "github.com/asparks1987/liblogit/languages/go/liblogit"

Beta target is a stable tagged module path with public examples.

Package Readiness Matrix

Binding Metadata Build artifact proof Installed-consumer proof Shared fixtures Current tier
Python Yes Yes Yes Yes Closest to Beta baseline
C CMake package metadata Yes Partial install/consumer path Yes Alpha baseline
C++ CMake package metadata Yes Partial install/consumer path Yes Alpha baseline
C# Yes Yes Partial Yes Alpha baseline
Java Yes Yes Partial Yes Alpha baseline
JavaScript Yes Yes Yes Yes Strong Alpha baseline
Go Module/package docs Yes Partial Yes Alpha baseline
Kotlin Companion package metadata Yes Partial Wrapper coverage Alpha baseline

What Still Needs To Happen

The remaining package work is very specific:

  1. Publish ecosystem-native artifacts instead of only proving local builds.
  2. Make consumer install examples part of the normal test matrix.
  3. Version every binding off the same release train.
  4. Record artifacts, checksums, and inspection output in release evidence.
  5. Turn current partial install stories into one-command public instructions.

If you are evaluating libLogit today:

  1. Start with the Python binding if you want the fullest feature set.
  2. Use starter project guides for the shortest language-by-language setup path.
  3. Use the language-specific examples in examples/ to mirror the portable LOGIT model in another binding.
  4. Use getting started for the object model.
  5. Use developer instructions for configuration details.
  6. Use the language matrix to understand what is already proven versus what is still Beta-track work.