Type System
Static + HM Inference
Type Inference + Runtime Optimization
Strict types. Self-optimizing runtime.
Model ideas with a tiny, expressive syntax. Keep strict static guarantees. Run it on Truffle with room for serious tooling and optimization work.
Runtime
GraalVM Truffle
Interop
Direct JVM Access
Source Focus
Read it like pseudocode, run it on an optimizing runtime.
Jot stays compact enough for fast iteration while keeping hard constraints in place. You get expressive syntax, precise type feedback, and runtime headroom.
Sharp compile-time feedback
Catch invalid assumptions before execution without sacrificing iteration speed.
Runtime profiling runway
Truffle internals leave room for performance work as the language evolves.
example.jot
fn fib(n: Int) -> Int {
if n <= 1 { n }
else { fib(n-1) + fib(n-2) }
}
print(fib(10))From file to execution
four-stage passstep 01
Parse
Jot source is translated into a compact AST designed for readable diagnostics.
step 02
Type Check
Inference resolves most types while still enforcing strict compile-time guarantees.
step 03
Specialize
Truffle nodes profile execution patterns and specialize hot paths over time.
step 04
Execute
Your program runs with JVM ecosystem access and room for runtime-level tooling.
Inference first, annotations optional
Hindley-Milner inference preserves type rigor without cluttering every function signature.
Truffle-native runtime internals
Built on GraalVM Truffle to keep optimization and tooling pathways open from the start.
Composable language core
A compact standard surface area designed to scale with modules, not accidental complexity.
JVM ecosystem leverage
Use existing JVM libraries and deployment infrastructure without losing language ergonomics.
Core mechanics
type system + runtimeEngineering brief
Hindley-Milner type inference
HM inference assigns type variables to expressions, then unifies constraints to discover one consistent type shape across a program.
In practice this means most function signatures can stay implicit while still giving compile-time errors and principled polymorphism.
Constraint solving via unificationGeneralization at let-bindingsPolymorphism without annotation-heavy code
Engineering brief
Truffle self-optimizing AST
Truffle starts from a generic AST and observes real execution behavior, such as stable operand shapes and call-site patterns.
Nodes rewrite themselves into specialized versions for hot paths, and can deoptimize back to safe generic behavior when assumptions break.
Profile-guided node specializationInline caches on dynamic dispatch pointsDeoptimization for correctness under change
Early-stage project
Status and roadmap
Jot is actively developed and not production-stable yet. APIs and language details may shift as we validate the core design and tooling story.
Follow on GitHub
Next focus: LSP, package story, profiling docs.
Install
Ship your first Jot script
curl -fsSL https://jotlang.dev/install.sh | bash
jot --version
jot run hello.jotVerify install with `jot --version`
Continue with the docs for module layout and tooling