01
Native build pipeline
Thagore builds native binaries through its Rust compiler pipeline and LLVM 14 backend. Current release assets ship for Windows, macOS, and Linux.
In development toolchain
A native language projectbuilt for resilient systems, measured in public, and still under active construction.
Thagore is a programming language designed for resilient and adaptable software, where programs can continue from prior state after interruption instead of treating every failure as a full restart. This page states what is shipped, what is measured, and what is still in progress.
What this page does
It describes the current toolchain, the strongest ideas behind the project, the measured performance numbers already published in the repository, and the work still ahead.
Shipped now
Current features and standout points
These are present in the current public line. They are not promises about an imagined future implementation.
02
Compiler tooling
The public toolchain includes `thagc`, release installers, formatter and LSP-oriented infrastructure, with current packaging centred on reproducible release manifests.
03
Browser playground
The playground uses a dedicated WASM build and browser-safe interpreter so documentation, examples and interactive checks stay aligned with the current language surface.
04
Current language focus
Today the strongest path is a typed, native-first language core with clear syntax, direct build/run workflows, and active work on stronger compile-time contracts.
Two core ideas
Flow and Intent are the clearest long-term bets
These are not presented as fully shipped language features today. They are the two strongest ideas behind Thagore's direction and the reason the project keeps pushing on compiler-visible structure instead of surface syntax alone.
01
Flow
Flow aims to let multi-step processes and workflows resume from earlier state after server restart or system disruption, reducing operational mistakes and improving application reliability.
02
Intent
Intent aims to let developers describe what the code is trying to achieve, so the compiler can apply bounded, testable optimizations or generate more effective code paths.
Measured and tested
Performance numbers from the public benchmark pack
Latest published benchmark pack in the repository: commit 8f82706e, timestamp 2026-03-03T17:55:52Z. These figures are reported as measured data, not as universal claims.
p50 for `thagc --version`, 20 samples
p50 for `thagc build`, 8 samples
p50 on the public benchmark pack, 12 samples
benchmark pack dated 2026-03-03 UTC
Public release verification for the current line includes installer, docs, Windows executable output, and playground deployment. Re-run the benchmark pack before making fresh performance statements.
Where Thagore is intended to matter
The near-term direction is resilient software and long-running operational systems, not generic hype about being for everything at once.
- Backend services
- Workflow automation
- Task pipelines
- Asynchronous processing systems
- Payment systems
- Order processing
- Distributed jobs
- AI workflows
Current public release facts
- Current public line: v0.9.6
- Windows, macOS and Linux release assets published
- Docs, installers and playground updated on the same line
- This project remains marked as in development
Future work
Longer-term range
Beyond the main resilience goal, Thagore is being kept light and flexible enough to expand into more domains over time.
Bootstrap and trust
Strengthen bootstrap contracts, seed toolchain rules, and release acceptance so public binaries match the source and CI story more closely.
Toolchain reliability
Reduce manual release handling, harden install/update paths, and keep cross-platform smoke checks as part of normal release work.
Future application range
Desktop applications with HTML-based UI, Android applications, game engines and scripting, developer tools, automation, and broader AI workflow systems are future-facing targets rather than present claims.
Long-term objective
The long-term objective is a unified programming platform where the same language can be used to build servers, applications, and more complex interactive systems without pretending that all of that already exists today.
Use the project carefully