v0.0.9 (Build 35) Released
Pre-Release

Kinetix

A compiled, statically typed systems programming language. An experimental project developed by a student with the advanced assistance of Artificial Intelligence.

main.kix
class Counter {
    state count: int = 0

    fn increment(&mut self) {
        self.count = self.count + 1
    }
}

fn main() {
    let mut c = Counter { count: 0 }
    
    effect [c.count] {
        println("Count changed to: " + c.count)
    }

    c.increment() // Triggers effect implicitly
}

Built for Predictability

Engineered to guarantee determinism without sacrificing high-level expressive power.

🛡️

Linear Ownership

Strict AST-based borrow validation. Say goodbye to race conditions and hidden aliases during compile-time without complex lifetimes.

Reactive Graph

A native frame scheduler built right into the Virtual Machine. State mutations trigger zero-overhead cached effects via topological sort.

🔒

Capability IR

Sandbox Enforcement at compile level. Functions inherently declare side-effects. Network and FS access checked before the bytecode is even emitted.

🚀

Zero GC

Deterministic Drop Order Verification and LLVM native bridging. Predictable performance scaling strictly O(n) under load.

Project Status

Il percorso di Kinetix verso una base stabile e solida.

Global Completion

Phase 0: Formal Core & Memory 100%
Phase 1: Compiler & Borrow System 100%
Phase 2: Types & Nominals Traits 100%
Phase 3: OOP & Reactive Engine 100%
Phase 4: Capability OS Abstraction 100%
Phase 5: Ecosystem & Networking 75%
Phase 6: Multimedia Native 0%
Phase 7: Full Stress Audit 0%
Phase 8 & 9: Native UI, Mobile & WASM 0%

Milestones

  • [✓] Phase 0 & 1: Memory Model, Formal HM Inference & Bytecode VM.
    • Complete EBNF Syntax & Lexer
    • Linear Types & Move Semantics implementation
    • 16-bit Bytecode VM architecture
    • Formal Type Inference (Hindley-Milner scope)
    • Differential Testing VM vs LLVM Native generation
  • [✓] Phase 2: Safe Monomorphization, Exhaustive Pattern Matching.
    • Safe Option<T> & Result<T,E> enforcing
    • Nominal Trait Constraint Resolution
    • Compile-Time Drop Order Verification
    • Exhaustiveness Checker Matrix Algorithm
    • Strict Post-Monomorphization Structural validation
  • [✓] Phase 3: OOP, Reactive Engine & Structs.
    • Linear Classes & Structs MVP compilation
    • Reactive Dag (State-Computed-Effect) topological sort
    • OOP Method Dispatch and VM Runtime hooks
    • Capability IR Sandbox verification (Build 19)
    • Pipeline Validation & IR Integrity Checks (Build 20)
    • Safe Default Init, Allocation Audit & Formal Invariants (Build 21)
    • Phase 3 Final Closure (Build 22)
  • [✓] Phase 4: Shell, System, Capability & Static VTable Dispatch.
    • Static VTable Dispatch pre-SSA
    • OS Abstraction Layer (system.*)
    • Syscall Mapping Table zero-runtime overhead
    • Holy-Shell style optional parens
    • Backticks Operator for subprocess integration
    • System Module Security under Sandbox rules
  • [~] Phase 5: Ecosystem, Net, Data FS & Compiler Optimization. (Current)
    • HTTP & Async Networking (Build 29)
    • TLS, Net Utils & Buffer Pooling (Build 30)
    • Core Filesystem IO and Sandbox Enforcing (Build 31)
    • Directories, Path Safety & Watch stub (Build 32)
    • .kicomp Project System & Offline Package Manager (Build 33)
    • Integrated LSP Server (Build 34)
    • Compiler Optimization Passes & Linker (Build 35)
    • VM & LLVM Backend Optimization (Build 36)
  • [ ] Phase 6: Multimedia (Buffered Audio Stream).
    • Non-blocking Buffered Audio Stream framework
    • FFI Safety Layer enforcement boundaries
    • Strict internal rendering coordinates abstraction
  • [ ] Phase 7: Full Stress Validation, Fuzzy Tests & Performance Global Audit.
    • Complete Test Suite for every module (Compiler, VM, Builtins)
    • Stress Test: Generics explosion, Borrow graph limits, Recursive TCO
    • Fuzzing & Differential Tests (VM vs LLVM MD5 comparison)
    • Coverage Target ≥ 85% on stable core
    • VS Code Extension Integration (Highlighting, LSP connection, Debugger)
  • [ ] Phase 8: Cross-Platform UI Stabilization (Separated backend for GUI and TUI).
    • Complete deprecation and removal of old graph lib
    • GUI (gui.*): Desktop/Mobile windowing API (Vulkan, Metal, DirectX backend)
    • TUI (tui.*): Advanced terminal management, Double buffering, Zero flicker
  • [ ] Phase 9: Mobile Runtime & Extended Platform Support (iOS, Android, WASM).
    • Mobile Runtime: OS-specific separation, NDK Android support
    • Mobile specific Sub-Libraries (gui.mobile.*, tui.mobile.*)
    • Platform Targets output: Android (aarch64) & iOS (arm64 iOS Metal)
    • WASM Target compiler with WASM-compatible runtime
    • Platform Constraints enforcement (No iOS JIT, No Syscalls for Sandbox)

Kinetix Changelog