konpeito 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e06886ab2b9bd1bcc2638dcc1c0788c7a0bbe40c0416a630eb89ca8e86945a7a
+  data.tar.gz: 3921d4b460e10864329173fcdf6ba0c925c89ad9d7959fab5ac74c640041e0e4
+SHA512:
+  metadata.gz: 970fff312f787c003978377350ff5cbeeccd46aab454999b1214d1c17a2e04530c2ec9149a4015b6c477cd21984b43ebf03390120cd1ce9b22670fe767845338
+  data.tar.gz: 32b1f3c137e224a89f57df986f667a3bc4fbe9ea12997b340927ed70e7b00458b10106be3b1f827f86ff4e147e79eafc94601b4026ce225284e4fe2d06a4597c

data/.ruby-version

@@ -0,0 +1 @@
+4.0.1

data/CHANGELOG.md

@@ -0,0 +1,75 @@
+# Changelog
+
+All notable changes to Konpeito will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.0] - 2026-02-13
+
+### Added
+
+#### Compiler Core
+- Prism parser integration for Ruby 4.0 syntax
+- Hindley-Milner type inference (Algorithm W) with RBS integration
+- High-level IR (HIR) with SSA form
+- Typed AST generation
+
+#### LLVM Backend (CRuby Extension)
+- Native code generation via LLVM 20
+- CRuby extension output (.so/.bundle)
+- Unboxed arithmetic for Integer/Float (5-5000x faster than YJIT)
+- Monomorphization and function inlining
+- Loop-invariant code motion (LICM)
+- LLVM O2 optimization pass integration
+
+#### JVM Backend
+- Standalone .jar generation via ASM bytecode
+- Java 21 Virtual Threads support
+- Java interop (RBS-free, classpath introspection)
+- Block-to-SAM conversion
+- Pattern matching (Array/Hash/Capture/Pin/Rest)
+- Module/Mixin support (include/extend/prepend)
+
+#### Native Data Structures
+- `NativeArray[T]` - contiguous unboxed arrays (up to 31x faster)
+- `NativeClass` - fixed-layout C structs with GC integration
+- `NativeHash[K,V]` - generic hash map with linear probing
+- `StaticArray[T,N]` - stack-allocated fixed-size arrays
+- `Slice[T]` - bounds-checked pointer views
+- `ByteBuffer` / `StringBuffer` / `ByteSlice`
+- `NativeString` - UTF-8 byte/char operations
+- `@struct` - value type structs (register passing)
+
+#### Standard Library
+- `KonpeitoJSON` - JSON parse/generate (yyjson)
+- `KonpeitoHTTP` - HTTP client (libcurl)
+- `KonpeitoCrypto` - cryptographic primitives (OpenSSL)
+- `KonpeitoCompression` - gzip/deflate/zlib compression
+
+#### Ruby Language Features
+- Classes, modules, inheritance, mixins
+- Blocks, yield, Proc/Lambda
+- Pattern matching (case/in with literals, arrays, hashes, guards, captures, pins)
+- Exception handling (begin/rescue/else/ensure)
+- Fiber, Thread, Mutex, ConditionVariable, SizedQueue
+- String interpolation, regular expressions, ranges
+- Keyword arguments, rest arguments, splat expansion
+- Compound assignment (`+=`, `||=`, `&&=`)
+- Safe navigation (`&.`), `defined?`, `alias`
+- Open classes, `class << self`, endless methods
+- Numbered block parameters (`_1`, `_2`), `it` parameter
+
+#### Developer Tools
+- LSP server (diagnostics, hover, completion, go-to-definition, references, rename)
+- DWARF debug info (`-g` flag, lldb/gdb support)
+- Profiling instrumentation (`--profile`)
+- Incremental compilation (`--incremental`)
+- Rust/Elm-style diagnostic error messages
+
+#### C Interop
+- `%a{cfunc}` / `%a{ffi}` - direct C function calls
+- `%a{extern}` - external C struct wrappers
+- `%a{simd}` - SIMD vectorization
+
+[0.1.0]: https://github.com/i2y/konpeito/releases/tag/v0.1.0

data/CONTRIBUTING.md

@@ -0,0 +1,123 @@
+# Contributing to Konpeito
+
+Thank you for your interest in contributing to Konpeito! This document provides guidelines and instructions for contributing.
+
+## Development Setup
+
+### Prerequisites
+
+- Ruby 4.0.1+
+- LLVM 20
+- Java 21+ (for JVM backend only)
+- Bundler
+
+### Installing LLVM 20
+
+**macOS:**
+```bash
+brew install llvm@20
+ln -sf /opt/homebrew/opt/llvm@20/lib/libLLVM-20.dylib /opt/homebrew/lib/
+```
+
+**Ubuntu / Debian:**
+```bash
+sudo apt install llvm-20 clang-20
+```
+
+**Fedora:**
+```bash
+sudo dnf install llvm20 clang20
+```
+
+**Windows (MSYS2 / MinGW):**
+```bash
+winget install LLVM.LLVM
+```
+
+### Setup
+
+```bash
+# Clone the repository
+git clone https://github.com/i2y/konpeito.git
+cd konpeito
+
+# Install Ruby 4.0.1
+rbenv install 4.0.1
+rbenv local 4.0.1
+
+# Install dependencies
+bundle install
+
+# Run tests
+bundle exec rake test
+```
+
+### Running Specific Tests
+
+```bash
+# All tests
+bundle exec rake test
+
+# JVM backend only
+bundle exec ruby -Ilib:test test/jvm/jvm_backend_test.rb
+
+# Specific test file
+bundle exec ruby -Ilib:test test/codegen/rescue_else_test.rb
+```
+
+## How to Contribute
+
+### Reporting Bugs
+
+1. Check existing [issues](https://github.com/i2y/konpeito/issues) to avoid duplicates
+2. Use the bug report template
+3. Include: Ruby version, LLVM version, OS, minimal reproduction code
+
+### Suggesting Features
+
+1. Open an issue using the feature request template
+2. Describe the use case and expected behavior
+3. If proposing a syntax extension, show example Ruby code and expected compiled output
+
+### Submitting Pull Requests
+
+1. Fork the repository
+2. Create a feature branch (`git checkout -b feature/my-feature`)
+3. Make your changes
+4. Add tests for new functionality
+5. Ensure all tests pass (`bundle exec rake test`)
+6. Submit a pull request using the PR template
+
+### Code Style
+
+- Follow existing code patterns in the codebase
+- No trailing whitespace
+- Use 2-space indentation (Ruby standard)
+- Add tests for all new features and bug fixes
+
+## Architecture Overview
+
+See [docs/architecture.md](docs/architecture.md) for a detailed architecture guide.
+
+Key directories:
+
+| Directory | Purpose |
+|-----------|---------|
+| `lib/konpeito/parser/` | Prism parser adapter |
+| `lib/konpeito/type_checker/` | HM type inference + RBS |
+| `lib/konpeito/hir/` | High-level IR |
+| `lib/konpeito/codegen/` | LLVM and JVM code generation |
+| `lib/konpeito/stdlib/` | Native standard library (C extensions) |
+| `tools/konpeito-asm/` | JVM ASM tool (JSON IR to .class) |
+| `test/` | Test suite |
+
+## Compiler Design Principles
+
+1. **No ambiguous behavior**: If a type cannot be determined, fall back to dynamic dispatch with a warning — never guess heuristically. Adding RBS promotes the fallback to static dispatch
+2. **HM inference is primary, RBS is auxiliary**: Code should compile correctly without RBS files
+3. **No heuristic guessing**: Never search all classes to guess which one has a matching method name
+4. **Follow Kotlin's design for JVM**: Kotlin is the reference for JVM type inference and code generation
+
+## License
+
+By contributing to Konpeito, you agree that your contributions will be licensed under the [BSD Zero Clause License (0BSD)](LICENSE).

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yasushi Itoh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,257 @@
+# Konpeito
+
+> *Konpeito (konpeitō) — Japanese sugar crystals. Crystallizing Ruby into native code.*
+
+A gradually typed Ruby compiler with Hindley-Milner type inference, dual LLVM/JVM backends, and seamless Java interop.
+
+Write ordinary Ruby. Konpeito infers types automatically, compiles to fast native code, and falls back to dynamic dispatch where it can't resolve statically — with a warning so you always know.
+
+## How It Works
+
+Konpeito uses a three-tier type resolution strategy:
+
+1. **HM inference** resolves most types automatically — no annotations needed. Like Crystal, but for Ruby.
+2. **RBS annotations** add precision where needed. Optional type hints that help the compiler optimize further.
+3. **Dynamic fallback** handles the rest. Unresolved calls compile to runtime dispatch (LLVM: `rb_funcallv`, JVM: `invokedynamic`), and the compiler warns you.
+
+Adding an RBS signature promotes a dynamic fallback to static dispatch. The compiler tells you where the boundaries are — fix them if you want, or leave them dynamic. Your call.
+
+## Quick Start
+
+### Prerequisites
+
+Ruby 4.0+ is required. Java 21+ is needed for the JVM backend. LLVM 20 is needed only for the CRuby native backend.
+
+```bash
+gem install konpeito
+```
+
+**JVM backend** (recommended — standalone JARs, Castella UI, Java interop):
+```bash
+# macOS
+brew install openjdk@21
+
+# Ubuntu / Debian
+sudo apt install openjdk-21-jdk
+
+# Fedora
+sudo dnf install java-21-openjdk-devel
+
+# Windows (MSYS2 / MinGW)
+winget install EclipseAdoptium.Temurin.21.JDK
+```
+
+**CRuby native backend** (optional — C extensions):
+```bash
+gem install ruby-llvm
+
+# macOS
+brew install llvm@20
+ln -sf /opt/homebrew/opt/llvm@20/lib/libLLVM-20.dylib /opt/homebrew/lib/
+
+# Ubuntu / Debian
+sudo apt install llvm-20 clang-20
+
+# Fedora
+sudo dnf install llvm20 clang20
+
+# Windows (MSYS2 / MinGW)
+winget install LLVM.LLVM
+```
+
+### Hello World
+
+Write a small Ruby file:
+
+```ruby
+# math.rb
+def add(a, b)
+  a + b
+end
+
+def sum_up_to(n)
+  total = 0
+  i = 1
+  while i <= n
+    total = total + i
+    i = i + 1
+  end
+  total
+end
+```
+
+Compile and use it from Ruby:
+
+```bash
+konpeito build math.rb          # produces math.bundle (macOS), math.so (Linux), or math.dll (Windows)
+```
+
+```ruby
+require_relative "math"
+puts add(3, 4)        # => 7
+puts sum_up_to(100)   # => 5050
+```
+
+A few more commands to get you going:
+
+```bash
+konpeito doctor                        # check your environment
+konpeito run --target jvm main.rb      # compile and run in one step
+konpeito fmt                           # format source files
+konpeito fmt --check                   # check formatting without modifying
+```
+
+## Features
+
+- **HM Type Inference** — Types are inferred automatically. No annotations needed for most code.
+- **Gradual Typing** — Static where possible, dynamic where necessary. The compiler shows you the boundary.
+- **Flow Typing** — Type narrowing via `if x.nil?`, `case/in Integer`, boolean guards, and more.
+- **Unboxed Arithmetic** — Integer and Float operations compile to native CPU instructions, skipping Ruby's method dispatch entirely.
+- **Loop Optimizations** — LICM, inlined iterators (`each`, `map`, `reduce`, `times`), and LLVM O2 passes.
+- **CRuby C Extensions** — Output plugs directly into your existing Ruby app via `require`.
+- **JVM Backend** — Generate standalone `.jar` files that run on any Java 21+ VM.
+- **Java Interop** — Call Java libraries directly with full type safety. Java type information flows into HM inference automatically.
+- **Native Data Structures** — `NativeArray[T]`, `NativeHash[K,V]`, `StaticArray[T,N]`, `Slice[T]`, `@struct` value types for high-performance data handling.
+- **C Interop** — Call external C libraries with `%a{cfunc}` / `%a{ffi}`, plus built-in HTTP (libcurl), Crypto (OpenSSL), and Compression (zlib) modules.
+- **SIMD Vectorization** — `%a{simd}` compiles vector types to LLVM vector instructions.
+- **Operator Overloading** — Define `+`, `-`, `*`, `==`, `<=>`, etc. on your own classes with full type inference.
+- **Pattern Matching** — Full `case/in` support with array, hash, guard, and capture patterns.
+- **Modern Ruby Syntax** — `_1`/`_2` numbered params, `it`, endless methods, `class << self`, safe navigation (`&.`), and more.
+- **Concurrency** — Fiber, Thread, Mutex, ConditionVariable, SizedQueue, and Ractor (with `Ractor::Port`, `Ractor.select`, `Ractor[:key]` local storage, `name:`, `monitor`/`unmonitor`). JVM Ractor uses Virtual Threads for scheduling but does not enforce object isolation — objects are shared by reference, unlike CRuby's strict isolation model.
+- **Built-in Tooling** — Formatter (`fmt`), LSP (hover, completion, go-to-def, references, rename), debug info (`-g`), and profiling (`--profile`).
+- **Castella UI** — A reactive GUI framework for the JVM backend (see below).
+
+## JVM Backend
+
+Konpeito can also compile to JVM bytecode, producing standalone JAR files:
+
+```bash
+konpeito build --target jvm -o app.jar main.rb
+# or compile and run immediately:
+konpeito build --target jvm --run main.rb
+```
+
+The JVM backend supports seamless Java interop — call Java libraries directly from your Ruby code without writing any glue. Java type information is introspected from the classpath and fed into HM inference, so calling Java APIs is type-safe without annotations.
+
+## Castella UI
+
+Castella is a reactive GUI framework that runs on the JVM backend, powered by [JWM](https://github.com/nicenote/jwm) + [Skija](https://github.com/nicenote/skija) for cross-platform rendering. Based on a port of [Castella for Python](https://github.com/i2y/castella).
+
+```ruby
+class CounterApp < Component
+  def initialize
+    super
+    @count = state(0)
+  end
+
+  def view
+    label = "Count: " + @count.value.to_s
+    Column(
+      Text(label).font_size(32),
+      Row(
+        Button("  -  ").on_click { @count -= 1 },
+        Button("  +  ").on_click { @count += 1 }
+      )
+    )
+  end
+end
+```
+
+A block-based DSL is also available:
+
+```ruby
+def view
+  column(padding: 16.0) do
+    text "Counter: #{@count}", font_size: 24.0, color: 0xFFC0CAF5
+    row(spacing: 8.0) do
+      button("-", width: 60.0) { @count -= 1 }
+      button("+", width: 60.0) { @count += 1 }
+    end
+  end
+end
+```
+
+Available widgets: `Text`, `Button`, `TextInput`, `MultilineText`, `Column`, `Row`, `Image`, `Checkbox`, `Slider`, `ProgressBar`, `Tabs`, `DataTable`, `TreeView`, `BarChart`, `Markdown`, and more.
+
+## Performance
+
+Konpeito shines in compute-heavy, typed loops where unboxed arithmetic and backend optimizations kick in. All benchmarks compare against Ruby 4.0.1 with YJIT enabled on Apple M4 Max.
+
+### LLVM Backend (CRuby Extension)
+
+| Benchmark | vs Ruby (YJIT) |
+|---|---|
+| N-Body simulation (5M steps) | **81x** faster |
+| Numeric method inlining (abs, even?, odd?) | **25-29x** faster |
+| Range enumerable (each, reduce, select) | **40-53x** faster |
+| Integer#times (nested, typed) | **891-972x** faster |
+| Typed reduce over Array[Integer] | **7x** faster |
+| Loop sum (n=100) | **18x** faster |
+| Typed counter loop (LICM + LLVM O2) | **5,345x** faster |
+| StaticArray/NativeArray sum (4 elements) | **65x** faster |
+| StaticArray/NativeArray sum (16 elements) | **232x** faster |
+
+These numbers compare native-internal performance (the loop itself runs inside compiled code). Single cross-boundary calls see smaller gains due to CRuby interop overhead.
+
+### JVM Backend (Standalone JAR)
+
+Benchmarks run on Java 21 (HotSpot) with JIT warmup. "Realistic" mode uses variable arguments to prevent constant folding.
+
+| Benchmark (10M iterations) | Ruby (YJIT) | Konpeito JVM | Speedup |
+|---|---|---|---|
+| Multiply Add (realistic) | 196 ms | 5.0 ms | **39x** faster |
+| Compute Chain (realistic) | 300 ms | 5.1 ms | **59x** faster |
+| Arithmetic Intensive (realistic) | 272 ms | 5.0 ms | **55x** faster |
+| Loop Sum (realistic) | 107 ms | 2.6 ms | **41x** faster |
+| Fibonacci fib(30) x 10 (recursive) | 300 ms | 9.8 ms | **31x** faster |
+
+The JVM backend benefits from HotSpot's JIT compilation on top of Konpeito's static type resolution, yielding **30-60x** speedups for numeric workloads.
+
+> **Environment:** Apple M4 Max, Ruby 4.0.1 + YJIT, Java 21.0.10 (HotSpot), macOS 15.
+
+## Documentation
+
+### User Guides
+
+- **[Getting Started](docs/getting-started.md)** — Installation, Hello World, first project, Castella UI tutorial
+- **[CLI Reference](docs/cli-reference.md)** — All commands, options, and configuration
+- **[API Reference](docs/api-reference.md)** — Castella UI widgets, native data structures, standard library
+
+### Architecture & Design
+
+- **[Architecture](docs/architecture.md)** — Full compiler pipeline, design philosophy, and roadmap
+- **[JVM Backend](docs/architecture-jvm.md)** — Dual-backend strategy, JVM codegen, Java interop
+- **[Castella UI](docs/castella-ui.md)** — GUI framework design and widget reference
+- **[Native Stdlib Proposal](docs/native-stdlib-proposal.md)** — NativeArray, StaticArray, Slice, and friends
+- **[Language Specification](docs/language-specification.md)** — Supported syntax, type system rules, backend behavior
+- **[RBS Requirements](docs/rbs-requirements-en.md)** — When you need RBS files and when you don't
+
+## Requirements
+
+| Dependency | Version | Required for |
+|---|---|---|
+| Ruby | 4.0.1+ | Always |
+| Java | 21+ | JVM backend |
+| LLVM | 20 | CRuby native backend |
+| ruby-llvm gem | ~> 20.1 | CRuby native backend |
+| Platform | macOS (ARM64/x64), Linux (x64/ARM64), Windows (x64, MSYS2/MinGW) | — |
+
+## Built with AI
+
+This project was developed collaboratively between a human director ([Yasushi Itoh](https://github.com/i2y)) and [Claude Code](https://claude.com/claude-code) by Anthropic. The human set the vision, made design decisions, and guided the direction; the AI wrote the implementation. It's an experiment in what's possible when human judgment meets AI capability.
+
+## Status
+
+Konpeito is in an early stage. Bugs and undocumented limitations should be expected. Actively improving — bug reports and feedback are very welcome.
+
+The JVM backend might be more mature than the LLVM/CRuby backend at this point. If you're getting started, try the JVM backend first (`--target jvm`).
+
+## Contributing
+
+Contributions are welcome! Please see [CONTRIBUTING.md](CONTRIBUTING.md) for setup instructions and guidelines.
+
+The core principle: **no ambiguous behavior**. If the compiler can't determine a type, it falls back to dynamic dispatch with a warning — never guesses heuristically. Adding RBS promotes the fallback to static dispatch.
+
+## License
+
+[MIT](LICENSE) — Copyright (c) 2026 Yasushi Itoh

data/Rakefile

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task default: :test

data/bin/konpeito

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "konpeito"
+
+Konpeito::CLI.new(ARGV).run

data/konpeito.gemspec

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "lib/konpeito/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "konpeito"
+  spec.version = Konpeito::VERSION
+  spec.authors = ["Yasushi Itoh"]
+  spec.email = ["i2y@users.noreply.github.com"]
+
+  spec.summary = "A gradually typed Ruby compiler with dual LLVM/JVM backends"
+  spec.description = "Konpeito is a gradually typed ahead-of-time compiler for Ruby with " \
+                     "Hindley-Milner type inference and dual LLVM/JVM backends. Compile Ruby " \
+                     "to CRuby C extensions (.so) or standalone JARs with seamless Java interop. " \
+                     "Includes Castella UI, a reactive GUI framework powered by Skia, " \
+                     "based on a port of Castella for Python (github.com/i2y/castella)."
+  spec.homepage = "https://github.com/i2y/konpeito"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 4.0.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/main/CHANGELOG.md"
+  spec.metadata["bug_tracker_uri"] = "#{spec.homepage}/issues"
+
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?(*%w[test/ spec/ features/ .git .github appveyor Gemfile
+                          benchmark/ docs/ examples/ tmp/ CLAUDE.md])
+    end
+  end
+  spec.bindir = "bin"
+  spec.executables = ["konpeito"]
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "prism"
+  spec.add_dependency "rbs"
+  spec.add_dependency "language_server-protocol", "~> 3.17"
+
+  # ruby-llvm is optional — only needed for native/CRuby extension compilation (--target native).
+  # JVM backend (--target jvm), type checking, LSP, and formatting work without it.
+  # Install manually: gem install ruby-llvm
+end