GALEIKAN Download
ONE LANGUAGE. MULTIPLE WAYS TO WORK.WINDOWS / LINUX

The world’s first fully AI-developed hybrid programming language.

Galeikan is a Hybrid Language with Focus on Security Research.

Binary/low level analysis simplified. Go from a quick script to a native executable without changing the language you write.

Get Galeikan Explore the language
01 / DOWNLOADCHOOSE YOUR PLATFORM

Start building.

Choose your platform. Download links update when a complete new release is available.

Windows

Galeikan-0.1.0-preview1.1-windows-x64-setup.exe

Download

Linux

galeikan_0.1.0.preview1_amd64.deb

Download
Source code

Implementation, build scripts, and examples.

View on GitHub

Unsigned preview builds. Verify SHA-256 checksums before installation.

02 / THE LANGUAGESCRIPT + COMPILE

One syntax.
Two workflows.

Use Galeikan to explore an idea immediately, then compile supported code to a native executable. The language stays the same. The current native compiler covers a substantial but incomplete subset of the interpreter.

01 / GALEIKANSCRIPT · .GAKS

Stay close to the question.

Run a file directly or use the bytecode VM. Import local modules with familiar, concise syntax. Capture data, inspect it, and iterate without a build cycle.

galeikan run examples/inspect_script.gaks
02 / GALEIKANLANG · .GAK

Take the work with you.

Compile the supported subset into an x86-64 Windows PE or Linux ELF executable. A native binary can still use the explicit Python process bridge when Python is available.

galeikan compile examples/native_scalar.gak

The extensions indicate intended use, not different syntax: both .gak and .gaks can be interpreted or compiled when their features are supported.

03 / RESEARCH WORKFLOW

From bytes
to evidence.

Capture bounded input, inspect a real format, and keep the provenance of every observation. Galeikan’s Source, Observation, and Finding values are built around research that can be retraced.

  • PE and ELF metadata, sections, dependencies, and relocations
  • x86 instruction decoding and process-region inspection
  • Network and file access declared up front
  • Verifiable case records with source lineage
See technical details
entry_linear.gakGALEIKAN
01requires { file.read }
02import std.cli
03import std.binary
04import std.formats
05import std.asm
06
07let source: Source = binary.analyze(cli.arg(0), 67108864)
08let report: Format = formats.probe(source)
09let instructions: Disassembly = asm.linear(report, cli.int(1))
10
11impact instructions
12for instruction in instructions {
13    impact instruction
14}
BOUNDED INPUTTRACEABLE OUTPUT
04 / PYTHON INTEROPCROSS-LANGUAGE BY DESIGN

Keep Python
in your toolkit.

Galeikan does not ask you to leave existing Python analysis code behind.

Import a project-local Python module from Galeikan with a familiar module path. Declare python.exec explicitly and grant Python access when running. The bridge passes bounded typed data across a persistent process, so repeated calls can keep module state.

It works in both directions: Python can call Galeikan functions through the optional bridge package. Supported native Galeikan executables can call Python too, as long as a compatible Python installation and the module files are available on the target system.

Python bridge details
PYTHON + GALEIKAN
requires { python.exec }
from py.py_helper import double as python_double
import helper

fn report(value: i64) -> i64 {
    return python_double(helper.adjust(value))
}

print report(20)

Typed values · explicit permission · module content check

05 / DESIGN PRINCIPLESRESEARCH WITHOUT FRICTION

A sharper way
to reason about bytes.

Galeikan connects the quick feedback of a script with research primitives that normally require a stack of separate tools. Its defaults keep inputs bounded and effects visible while letting you choose the execution path that fits the work.

01 / SOURCE LINEAGE

Know where evidence came from.

Snapshots, views, and derived observations retain their source context so findings can be traced back to the bytes that produced them.

02 / EXPLICIT EFFECTS

Make intent inspectable.

File, network, process, Python, and case-writing operations are declared in source and granted at launch.

03 / HYBRID EXECUTION

Move from idea to artifact.

Run directly, use bytecode, or compile supported programs for Windows and Linux without switching syntax.

04 / PYTHON INTEROP

Bring existing tools along.

Call project-local Python modules from Galeikan, or call Galeikan functions from Python through the optional bridge.

06 / CODE EXAMPLESREAL PREVIEW PROGRAMS

Read the language.
Then run it.

Concise imports, typed results, and domain-focused modules. These examples follow programs in the current source tree.

01 / BINARY SNAPSHOT.gaks

Inspect bytes immediately

Run this script directly to count zero bytes and fingerprint a small sample.

import std.binary
import std.iter

let sample: Source = binary.snapshot(binary.from_hex("47 41 4b 00 90 90 00 01"))
var zero_bytes: i64 = 0

for offset in iter.range(binary.size(sample)) {
    let byte: Observation = binary.deep(sample, offset, "u8")
    if binary.value(byte) == 0 {
        zero_bytes = zero_bytes + 1
    }
}

print zero_bytes
print binary.sha256(sample)
View full script ↗
02 / NETWORK CAPTURE.gak

Bound a TCP exchange

Send an explicit request and cap both response size and wait time.

requires { net.connect }
import std.cli
import std.net
import std.binary

let request = binary.from_hex(cli.arg(2))
let response = net.exchange(cli.arg(0), cli.int(1), request, 65536, 3000)
print response
print binary.sha256(response)
View full example ↗
03 / TRACEABLE FINDINGS.gak

Record an observation

Turn a byte-level reading into a named finding with source context.

requires { case.write }
import std.binary
import std.audit

let source: Source = binary.snapshot(binary.from_hex("47 41 4b 00"))
let signature: Observation = binary.deep(source, 0, "u16le")
impact audit.expect(signature, 16711, "header.signature")
View full example ↗
FILE TYPES.gak / .gaks
EXECUTIONInterpreter / VM / Native
TARGETSWindows x64 / Linux amd64
FOCUSSecurity research
07 / GO DEEPER

Built to inspect.
Built to explain.

Explore the implementation boundaries, the complete research feature set, and answers to practical setup questions.

Technical details ↗Frequently asked questions ↗