Hello World

Why Objeck?

Built for modern development:

• 🚀 JIT-compiled for performance (ARM64/AMD64)
• 🤖 AI-native: OpenAI, Gemini, Ollama, ONNX, OpenCV — no third-party packages
• 🌐 Network-complete: HTTP/1.1 · HTTP/2 · HTTP/3/QUIC · WebSocket · DTLS — all standard library
• 💻 Developer-friendly: REPL shell, LSP plugins for VSCode/Sublime/Kate, DAP debugger
• 🌍 Cross-platform: Linux, macOS, Windows (x64 + ARM64/RPI)
• 🔧 Full-featured: Threads, generics, closures, reflection, serialization

Perfect for: AI/ML prototyping • Computer vision • Web services • Real-time applications • Game development

Try It Online

👉🏽 Playground — 33 demos across 7 categories, Monaco editor, no install required.

Quick Start

# Install (example for macOS/Linux)
curl -LO https://github.com/objeck/objeck-lang/releases/download/v2026.9.0/objeck-linux-x64_2026.9.0.tgz
tar xzf objeck-linux-x64_2026.9.0.tgz
export PATH=$PATH:./objeck-lang/bin
export OBJECK_LIB_PATH=./objeck-lang/lib

# Hello World
echo 'class Hello {
  function : Main(args : String[]) ~ Nil {
    "Hello World"->PrintLine();
  }
}' > hello.obs

# Compile and run (modern syntax)
obc hello && obr hello

📖 Full docs: objeck.org 💡 Examples: github.com/objeck/objeck-lang/programs

What's New

v2026.9.0 ✅

• A server that wrote a response and closed could lose all of it — on Windows loopback the reader got a connection reset and zero bytes, even though every byte had been accepted and delivered. TCPSocket and TCPSecureSocket gain CloseGracefully(), which reads until the peer hangs up and then closes, so the client owns the teardown. Measured over 180 transfers of a 16KB response: Close() lost 21, CloseGracefully() lost none
• The language server serialized every request behind one lock — concurrent analysis was correct only because of it, with TreeFactory and TypeFactory as process-wide singletons underneath. They are now bound per thread through a scope guard, so each analysis gets its own and the coarse lock gives way to per-program locking
• Four publish steps reported success while doing nothing — Sourceforge, the Marketplace, the playground and the API docs each skipped on an absent credential and passed, so v2026.8.4 published with all four green while the playground served a three-month-old engine. A missing credential now fails and names the secret, or is declared manual in one place that also prints as a to-do, and a pre-flight gate checks the pipeline can do what it advertises before the tag is pushed

v2026.8.4

• Game.OpenGL — 3D graphics for Objeck — OpenGL 3.3 core over SDL2 on Windows, Linux and macOS. 26 classes covering windowing and frame pacing, built-in shaders, meshes and OBJ loading, textures, cameras, materials, up to eight directional/point/spot lights with Blinn-Phong specular, shadow maps including omnidirectional cube shadows, render-to-texture, instancing through a one-call PropBatch, frustum culling, raycasting for hitscan and picking, gamepad input, a pixel-space text overlay, and a scene that answers collision. The examples got shorter as it grew — the minimal window demo went from 105 lines to 25, and per-frame allocations in both original draw loops went to zero. Verified by 453 checks that read pixels back rather than merely exiting cleanly, and two demos ship in the distribution
• Web.Server could not be used by anyone — it shipped in every release with 13 native entry points that existed in exactly one file: the binding itself. No .cpp, no build target, no library in any deploy tree, and Request/Response declared no constructor, so a program could not obtain an instance at all. Writing the missing native library was never an option — the design is a per-host bridge for Nginx, IIS and Apache, whose request structures differ entirely, so one generic library cannot exist. It is now implemented in pure Objeck over Web.HTTP.Server: same bundle, same class names, same signatures, no native library. Coverage went from 0 of 13 methods to 13 of 13
• The JIT silently computed the wrong answer above 2³¹ — 64-bit immediates were truncated to 32 bits: on AMD64 for and, or, xor, add and sub, and on Windows ARM64 for every one of them, where long is 32 bits under LLP64. No crash and no diagnostic, just wrong arithmetic. A stored float compare also clobbered a callee-saved register on AMD64. Windows ARM64 had shipped untested since February, which is why its variant survived
• A server that wrote and closed could lose the response — on Windows loopback, roughly 47% of responses, because the sender tearing down first discards what the receiver has not read. HTTP now uses keep-alive, removing the exposure rather than hiding it. Alongside it: a short send() silently dropped the rest of the buffer on both platforms, a real HTTP 500 lost its body while a dead socket reported one, and one failed name lookup called WSACleanup and shut Winsock down for the whole process — every open socket on every thread
• Three ways a live object could be collected — an array returned by a VM trap held elements a minor collection could destroy (measured at 395 of 395 entries lost in one collection: arrays are born old, objects young, and the trap array was never dirtied through the write barrier); a value returned by a native library could be collected out of a reused argument buffer; and the JIT's Int[] copy dropped the write barrier entirely
• Windows ARM64 installs shipped without their runtimes — no C++ redistributable, because VCToolsRedistDir is empty on the ARM64 runner, and OpenCV without its image codecs. Nothing checked either, so both failed on the user's machine rather than in CI. Cross-architecture native dependencies are now verified during the build
• A server that returns normally from Main no longer segfaults — a thread blocked in a syscall never observes the halt request, so teardown freed the program image while that thread was still live, and WSACleanup on the way out then unblocked it into freed memory — losing all buffered output, so it looked as though the program had done nothing. Linux was always clean for one reason: it has no equivalent call
• The debugger had the same defect, and there it was not Windows-only — obd hosts the debuggee's VM in-process and freed the program image and the whole GC heap after every run, halting and waiting for nothing. Because obd goes back to its prompt rather than exiting, an ordinary client connecting to the port the parked thread sits on wakes it with no WSACleanup involved: 6 access violations in 6 runs on Windows, 2 in 2 on Linux
• obd could not debug any multithreaded program — compiled with -debug, it segfaulted on the first instruction a spawned thread executed. Those threads are built by a constructor that never initialized the debugger pointer, and the per-instruction hook called through it. Only obd compiles that hook in, so obr was never affected
• Native calls got materially cheaper — a string literal allocates on every evaluation, and the literal naming the native function turned out to be 92% of a call's cost: 1655ns down to 130ns. Resolved entry points are now cached too, on every platform, removing a GetProcAddress/dlsym lookup and a wide-to-narrow conversion from every single call. Both are guarded by CI so they cannot drift back
• SDL2 loads on Windows without a hand-set PATH — the DLLs shipped in lib/sdl, but Windows resolves a dynamically-loaded library's imports against the executable's directory, never the library's, so libobjk_sdl.dll failed to load for anyone who had not added it themselves. Every SDL program was affected, and the regression runner hid it by prepending the directory first
• The API reference stopped omitting whole libraries — five files hard-code the library list and had drifted apart, one short two libraries while still naming a deleted third, so the counts matched and nothing looked wrong. Underneath, the doc parser was reading prose as code: the word "bundle" in a comment re-filed every class after it

v2026.8.3

• A corrupt library could crash the compiler — TypeParser::ParseType and ParseParameters switch on the first character of a type string and had no default case, so anything outside the known set — including an empty string, whose operator[](0) yields a null character — left the type null and was dereferenced immediately. The linker calls both on type strings read straight out of .obl files, so the input is not the compiler's own
• A } on the first line hung the REPL — an unsigned indent counter decremented at 0 wrapped to SIZE_MAX, and the indent loop below then ran about 1.8×10¹⁹ times. Listing and saving both hit it
• One malformed request no longer ends a debug session — only JSON parse errors were guarded, so a message that parsed but carried an unexpected type threw from inside the handler, unwound out of Run() to a main() with no handler, and terminated the process — losing every breakpoint and the running program over one bad request. Seven flags shared between the DAP and VM threads are atomics now: they were written under a mutex and read without one at every instruction, so nothing stopped an -O3 -flto build hoisting those loads out of the dispatch loop and a disconnect or step could go unseen indefinitely
• A connect that never completed could report success — getsockopt(SO_ERROR) was unchecked on both the POSIX and Windows connect-with-timeout paths, and both could hand back a socket still in non-blocking mode, so a caller expecting a blocking read got a spurious EAGAIN/WSAEWOULDBLOCK instead of data. The unchecked F_GETFL behind the POSIX case also restored garbage flags onto the socket
• One ONNX call reformatted every float for the rest of the run — both generation reports applied std::fixed with setprecision(1) directly to std::wcout and never restored it, and nothing on the Objeck side can clear a leaked floatfield. StdErrFloat carried the mirror-image bug: it read the saved state from std::wcout, modified std::wcerr and restored onto narrow std::cout — three different objects
• Two silent compiler mistakes — a lambda whose signature collided with an existing method was dropped with no diagnostic at all while the code carried on encoding and associating it, and one of MethodCall's five constructors left func_ref_unwrap indeterminate, so non-null garbage meant emitting a bogus call
• Entry points survive what they throw — obc, obr, obd and obi each had a long unprotected prologue (locale and codecvt construction, and the usage-string building that is a bad_alloc path) where anything thrown called terminate() with no message. Every entry point is now wrapped
• Windows installers are signed — and the notes claim it only when true — every Windows MSI from v2026.4.0 through v2026.8.2 shipped unsigned while the generated notes asserted otherwise: signtool was configured, ran, failed on every artifact, and the build warned and continued. The key is on a hardware token, so CI can never sign; signing is now an explicit local step, and a checker reports the real Get-AuthenticodeSignature status rather than inferring it from the file existing
• Coverity Scan on Windows as well as Linux — the first Windows scan turned up twenty real defects in cross-platform sources that MSVC compiles differently than GCC, so the Linux scan had never reached them. The scan token now lives outside the tree

📋 Full changelog • 🗺️ Roadmap • 📝 Editor & IDE setup

Downloads

Latest Release: v2026.9.0

📦 Alternative: Sourceforge • 📚 API Docs: objeck.org/api/latest

Note: Windows installers are signed and timestamped (CN=Randy Hollines, Sectigo); the macOS .pkg is signed and notarized. Signing uses a hardware token and therefore happens locally after publication, so verify rather than assume — Get-AuthenticodeSignature <file>.msi reports Valid only when it really is signed. Check any download against the release's SHA256SUMS, which is regenerated after signing. Builds are automated on GitHub Actions runners.

See It In Action

HTTP/2 Client

use Web.HTTP;

# Persistent connection — multiple requests share one TLS session
client := Http2Client->New("httpbin.org");
resp := client->Get("/get");
"Status: {$resp->GetCode()}"->PrintLine();    # Status: 200

body := "{\"lang\":\"objeck\"}"->ToByteArray();
resp2 := client->Post("/post", body, "application/json");
client->Close();

# One-liner for quick requests
resp := Http2Client->QuickGet(Url->New("https://httpbin.org/get"));

HTTP/3 / QUIC Client

use Web.HTTP;

# QUIC over UDP — zero round-trip connection on repeat visits
client := Http3Client->New("quic.nginx.org");
resp := client->Get("/");
"Status: {$resp->GetCode()}"->PrintLine();    # Status: 200
client->Close();

# One-liner
resp := Http3Client->QuickGet(Url->New("https://quic.nginx.org/"));

AI Integration

# OpenAI Realtime API - get text AND audio
response := Realtime->Respond("How many James Bond movies?",
                              "gpt-4o-realtime-preview", token);
text := response->GetFirst();
audio := response->GetSecond();
Mixer->PlayPcm(audio->Get(), 22050, AudioFormat->SDL_AUDIO_S16LSB, 1);

Face Recognition

# SCRFD detector + ArcFace R50 embeddings (InsightFace buffalo_l)
session := FaceSession->New("det_10g.onnx", "w600k_r50.onnx");
r1 := session->Recognize(img1_bytes, 0.5);
r2 := session->Recognize(img2_bytes, 0.5);
faces1 := r1->GetResults(); faces2 := r2->GetResults();
sim := FaceSession->Compare(faces1[0]->GetEmbedding(), faces2[0]->GetEmbedding());
"Same person: {$(sim > 0.35)}"->PrintLine();

Computer Vision

# OpenCV face detection
detector := FaceDetector->New("haarcascade_frontalface_default.xml");
faces := detector->Detect(image);
faces->Size()->PrintLine();  # "5 faces detected"

Natural Language Processing

# Sentiment analysis and TF-IDF
text := "This product is absolutely wonderful!";
sentiment := SentimentAnalyzer->Classify(text);  # "positive"

# Train TF-IDF on documents
docs := ["cats are pets", "dogs are pets", "birds can fly"];
tfidf := TF_IDF->New();
tfidf->Fit(docs);
vector := tfidf->Transform("cats and dogs");  # [0.47, 0.0, 0.47, ...]

🎯 More examples

Language Features

Object-Oriented

• Inheritance, interfaces, generics
• Type inference and boxing
• Reflection and dependency injection
• See OOP examples →

Functional

• Closures and lambda expressions
• First-class functions
• See functional examples →

Strings & Formatting

• Interpolation with expressions: "{$i + 1}", "{$obj->M()}"
• Format specifiers: "{$pi:.2}", "{$n:05}", "{$v:x}"
• Positional templates: String->Format("{0} = {1}", a, b)
• See string features →

Platform Support

• Unicode, file I/O, sockets, named pipes
• Threading with mutexes
• See platform features →

Libraries

AI & Machine Learning — 📖 AI Developer Guide · GitHub source · 🤖 Getting Models

• OpenAI — chat, vision, realtime audio, image generation, embeddings, moderation, batch
• Gemini — chat, vision, search grounding, files, context caching, batch embeddings
• Ollama — local LLM chat, vision, and embeddings; recommended models: llama3.2, phi3, llava (get models →)
• NLP — tokenization, TF-IDF, text similarity, sentiment analysis
• OpenCV — computer vision: detection, transforms, video
• ONNX Runtime — local ML inference: YOLO, ResNet, DeepLab, OpenPose, Phi-3, face recognition (get models →)
• Face Recognition — SCRFD detector + ArcFace R50 (InsightFace buffalo_l)
• Phi-3 / Phi-3 Vision — local SLM text and multimodal inference

Web & Networking

• HTTP/1.1 server/client, OAuth
• HTTP/2 — multiplexed TLS client via nghttp2
• HTTP/3 / QUIC — UDP-based client; ngtcp2 + nghttp3 on Linux/macOS, WinHTTP over MsQuic on Windows 11+
• RSS

Data

• JSON (hierarchical + streaming), XML, CSV
• SQL/ODBC, In-memory queries
• Collections

Graphics & Gaming

• 3D Graphics (OpenGL) — OpenGL 3.3 core: shaders, meshes, textures, cameras, lighting, shadows (setup & examples →)
• 2D Gaming (SDL)

Other

• Encryption, Regex

Development

Modern tooling and practices:

• 🤖 Claude Code for pair programming, debugging, and refactoring
• 🔄 CI/CD: Fully automated build, test, sign, and release pipeline (GitHub Actions)
  • ✅ Every push triggers multi-platform builds (Windows, Linux, macOS)
  • ✅ macOS installers signed and notarized in CI (Windows signing is a local step — hardware token)
  • ✅ One-tag releases: git tag v2026.2.1 → automated distribution in 60 minutes
  • ✅ Parallel builds across 6 platforms (x64/ARM64)
  • 📖 Release Process Documentation • CI/CD Architecture • System Architecture
• 🔍 Quality: CodeQL security scanning + gitleaks secret scanning
• 🧪 Testing: 350+ tests across 3 suites (regression, comprehensive, deploy)
  • Regression suite: 10 focused tests for critical functionality
  • Comprehensive suite: 323+ tests for full language validation
  • Deploy suite: 17 real-world usage examples
  • Full cross-platform coverage (Windows/Linux/macOS, x64/ARM64)

Editor Support:

• LSP plugins for VSCode, Sublime, Kate, Neovim, Emacs, Helix, and more
• REPL for interactive development
• API docs at objeck.org

📚 Testing Documentation • 🧪 Regression Tests • 📊 Performance & Benchmarks

Resources

• 📖 Documentation
• 🏗️ Architecture — Mermaid diagrams covering compiler, VM, JIT, libraries, and CI/CD
• 🎯 Examples
• 💬 Discussions
• 🐛 Issues