Skip to content

HackerOS-Linux-System/Hacker-Lang

BranchesTags

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 

History

303 Commits
examples
examples
 
 
images
images
 
 
main-libs
main-libs
 
 
source-code
source-code
 
 
tests
tests
 
 
Cargo.toml
Cargo.toml
 
 
LICENSE
LICENSE
 
 
README.adoc
README.adoc
 
 
build.hl
build.hl
 
 

Repository files navigation

Hacker Lang (HL) — gen 2

Spis treści

Hacker Lang to natywny język skryptowy HackerOS — interpretowany przez pipeline JIT (AST → bytecode → kod maszynowy Cranelift), z własną składnią operatorową, managerem pakietów bit i bezpośrednim dostępem do API HackerOS.

Warning

Hacker Lang działa wyłącznie na HackerOS. Binarka hl jest wbudowana w system.

Pipeline wykonania

.hl source  ──parse──►  AST  ──lower──►  .bc bytecode  ──JIT──►  kod maszynowy
                                              │
                              ~/.hackeros/hacker-lang/cache/
                              (max 30 plików, auto-cleanup)

Domyślnie hl run plik.hl:

  1. Parsuje .hl → AST

  2. Kompiluje AST → zoptymalizowany .bc (Cranelift IR bytecode)

  3. Cachuje .bc w ~/.hackeros/hacker-lang/cache/ (hash źródła + mtime)

  4. Uruchamia .bc przez interpreter bytecode + JIT engine (Cranelift)

  5. Gorące pętle/funkcje (≥50 wywołań) są kompilowane do natywnego kodu maszynowego

Składnia — gen 2 (domyślny)

Print

~> Tekst z interpolacją @zmiennej

Komendy

>   komenda            # zwykła
^>  komenda            # sudo
->  komenda            # izolacja namespace
^-> komenda            # sudo + izolacja
>>  komenda @var       # z interpolacją zmiennych
^>> komenda @var       # interpolacja + sudo
->> komenda @var       # interpolacja + izolacja
*>  komenda            # przez hsh -c (HackerOS shell)
&   komenda            # w tle (non-blocking), PID → @_bg_pid

Zmienne

% nazwa = wartosc           # gen 1 — bez typu
% nazwa: int   = 42         # gen 2 — int
% nazwa: float = 3.14       # gen 2 — float
% nazwa: str   = tekst      # gen 2 — string
% nazwa: bool  = true       # gen 2 — bool
@nazwa                      # odwołanie do zmiennej

Arytmetyka natywna (gen 2)

$( 2 + 2 )           -> @wynik    # oblicz i zapisz do zmiennej
$( @a * @b + 10 )    -> @res      # z interpolacją zmiennych
% x: int = $( 100 / 4 )           # jako wartość zmiennej

Pipe do zmiennej (gen 2)

> hostname       |> @host     # wynik komendy → zmienna
> uname -r       |> @kernel
^> id -u         |> @uid      # sudo pipe

Export

=> EDITOR = nvim
=> PATH [
| /usr/local/bin
| /usr/bin
| /usr/lib/HackerOS
]

Pętle (gen 2)

@ item in wartosc1 wartosc2 wartosc3   # for-in
    ~> element: @item
done

@ cmd in @lista_komend                 # for-in ze zmiennej
    ::which @cmd
done

?~ @licznik < 10                       # while
    $( @licznik + 1 ) -> @licznik
done

Switch/case (gen 2)

? switch @zmienna
| linux
    ::green Linux!
| windows
    ::yellow Windows!
| *
    ~> nieznany: @zmienna
done

Pętla N razy

_10 > hacker update
_5  ~> powtórzenie
_3  ::green OK

Funkcje

: nazwa def
    ~> ciało funkcji
done

-- nazwa     # wywołanie

Warunki

> test -f /etc/passwd
? ok
    ::green plik istnieje
done
? err
    ::red brak pliku
done

Goroutines i Channels (gen 1+2)

:** kanal          # zadeklaruj kanał

:* nazwa def       # goroutine z nazwą (gen 2)
    > jakies_zadanie
    *-- kanal
done

:*                 # goroutine anonimowa (gen 1)
    > inne_zadanie
done

*-- kanal          # odbierz z kanału

Import pliku

<< utils.hl
<< config.hl | szczegol

HackerOS API (gen 2)

|| hacker update
|| hpkg install nmap
|| lpm list
|| hsh -c "ls /tmp"
|| H# --version
|| hco status
|| hedit plik.txt
|| hnm scan
|| Blue-Environment start
|| hackeros-steam launch

Dostępne narzędzia: H# hco hacker hsh hpkg Blue-Environment hnm hpm hedit ngt eiq getit hdev anvil a hbuild lpm chker isolator hackeros-steam ulb gameframe hup hackeros-builder

Komentarze

;; komentarz liniowy
/// komentarz dokumentacyjny (widoczny w hl search)
// komentarz blokowy
   może być wieloliniowy
   kończy się \\

Zależności i importy

// curl             # deklaracja zależności (auto-install)
// nmap

# <main/net>        # biblioteka standardowa (.hl)
# <main/colors>
# <main/progress-bar>
# <main/json>
# <main/hk-parser>  # parser .hk (HackerOS Config)
# <main/hacker>     # parser .hacker v1/v2/v3
# <bit/hashlib>     # biblioteka bit (.so)
# <github/user/repo> # GitHub

Biblioteki main/ to pliki .hl w /usr/lib/HackerOS/Hacker-Lang/main-libs/.

Note

Stara składnia jest kompatybilna: # <std/net> → main/net, # <virus/hashlib> → bit/hashlib, # <community/u/r> → github/u/r

Quick Functions

::upper  tekst      # → TEKST
::lower  tekst      # → tekst
::len    tekst      # → długość
::trim   tekst      # → bez białych znaków
::rev    tekst      # → tskset
::replace @t s d    # zamień s→d
::contains @t sub   # exit 0/1
::split  @t :       # podziel
::abs    -42        # wartość bezwzgl.
::ceil   3.2        # → 4
::floor  3.9        # → 3
::round  3.5        # → 4
::max    10 20      # → 20
::min    10 20      # → 10
::rand              # 0-99
::env    HOME       # zmienna środow.
::date              # RRRR-MM-DD
::time              # GG:MM:SS
::pid               # PID procesu
::which  curl       # ścieżka narzędzia
::exists /etc/file  # exit 0/1
::isdir  /tmp       # exit 0/1
::isfile /etc/hosts # exit 0/1
::basename /a/b.c   # → b.c
::dirname  /a/b.c   # → /a
::read   plik.txt   # wyświetl zawartość
::set    n wartosc  # ustaw zmienną
::get    n          # pobierz zmienną
::type   n          # typ zmiennej
::unset  n          # usuń zmienną
::nl                # pusta linia
::hr     40         # ────────────
::bold   tekst      # pogrubiony
::red    tekst      # czerwony
::green  tekst      # zielony
::yellow tekst      # żółty
::cyan   tekst      # cyjanowy

CLI — binarka hl

hl plik.hl                  # uruchom skrypt (JIT pipeline)
hl run plik.hl              # jawna forma (JIT pipeline)
hl run plik.bc              # uruchom bytecode bezpośrednio przez JIT
hl run --no-jit plik.hl     # wymuś tree-walk interpreter (debug)
hl compile plik.hl          # .hl → plik.bc (bytecode, do katalogu źródłowego)
hl check plik.hl            # sprawdź składnię + linter
hl check --meta plik.hl     # + gen i shebang
hl ast plik.hl              # AST jako JSON
hl repl                     # REPL interaktywny
hl shell                    # HL jako powłoka systemowa
hl exec nazwa               # uruchom skrypt systemowy
hl search fraza             # szukaj skryptów systemowych
hl search all               # wylistuj wszystkie
hl gen-info plik.hl         # gen + shebang + węzły AST
hl docs                     # dokumentacja TUI
hl clean                    # wyczyść cache .bc + bibliotek
hl cache-info               # statystyki cache .bc
hl version                  # informacje o wersji
hl -c "~> Hej!"             # kod inline

Bytecode — format .bc

Pliki .bc to zoptymalizowany bytecode Hacker Lang (binarny):

[magic: "HLBC"]  [wersja: u32]  [len nagłówka: u64]
[nagłówek JSON: gen, źródło, timestamp]
[moduł bincode: instrukcje IR + pula stałych + tablica funkcji]

Pliki .bc mają automatycznie dodany shebang #!/usr/bin/env -S /usr/bin/hl run i bit wykonywalny — można je uruchamiać bezpośrednio.

Cache bytecode

Cache: ~/.hackeros/hacker-lang/cache/

  • Klucz cache: hash(zawartość źródła + ścieżka + mtime)

  • Limit: 30 plików .bc

  • Auto-cleanup: przy uruchamianiu 31. skryptu usuwa najstarsze pliki

  • Ręczne czyszczenie: hl clean

  • Podgląd: hl cache-info

JIT engine

JIT kompiluje gorące ścieżki do natywnego kodu maszynowego (x86_64/aarch64) przez Cranelift:

  • Próg: 50 wywołań funkcji/pętli → kompilacja do kodu maszynowego

  • Kwalifikują się: czyste pętle arytmetyczne, funkcje bez wywołań systemowych

  • Reszta (I/O, komendy systemowe): zawsze przez interpreter bytecode

  • Wyłączenie JIT: hl run --no-jit plik.hl lub HL_NO_JIT=1 hl run plik.hl

Kompilacja — pipeline

hl run skrypt.hl        # Automatyczny: .hl → cache .bc → JIT execute
hl compile skrypt.hl    # Jawna: .hl → skrypt.bc (w katalogu źródłowym)
hl run skrypt.bc        # Uruchom .bc bezpośrednio
./skrypt.bc             # Lub przez shebang (ma bit wykonywalny)
Tip

hl run plik.hl jest szybsze niż Ruby YJIT dla typowych skryptów systemowych dzięki lekkiemu bytecode i zero-overhead cache (bincode deserializacja).

Struktura projektu (Cargo workspace)

source-code/
├── parser/    -- Lexer, Parser, AST, Gen, Shebang
├── core/      -- Executor (tree-walk), Env, Quick Functions, Diagnostics
├── compiler/  -- Bytecode compiler: AST → HlModule (.bc)
│   ├── bytecode.rs   -- IR instrukcji (HlModule, Instruction, ConstPool)
│   ├── lower.rs      -- Lowering AST → HlModule
│   ├── optimize.rs   -- Optymalizator: constant folding, DCE, peephole
│   ├── serialize.rs  -- Format .bc: magic + bincode
│   └── cache.rs      -- Cache ~/.hackeros/hacker-lang/cache/
├── jit/       -- JIT engine: interpreter bytecode + Cranelift hot-path
│   ├── interpreter.rs -- Interpreter bytecode (cold path)
│   ├── jit_engine.rs  -- Cranelift JIT (warm path, ≥50 wywołań)
│   ├── runtime.rs     -- RuntimeState, RtVal
│   └── runner.rs      -- Główny entry point: run_hl_file / run_bc_file
├── shell/     -- REPL, Shell, Completion, Prompt
└── cli/       -- Binarka `hl` (clap)

Manager pakietów bit

Komendy

bit                     # auto-detect: run.hl / build.hl / source-code/
bit install hashlib     # zainstaluj pakiet
bit remove hashlib      # usuń pakiet
bit list                # lista dostępnych pakietów
bit update              # zaktualizuj listę pakietów
bit info hashlib        # informacje o pakiecie
bit help                # pomoc

Struktury projektu

Wariant 1 — run (interpretowany):
  run.hl          ← główny skrypt uruchomieniowy
  main.hl         ← kod źródłowy
  .cache/         ← izolowane środowisko (auto, usuwane po zakończeniu)

Wariant 2 — build (kompilowany):
  build.hl        ← konfiguracja budowania
  main.hl         ← kod źródłowy
  .cache/

Wariant 3 — source-code/ (rust-like):
  source-code/    ← katalog z kodem źródłowym
  build.hl        ← konfiguracja budowania
  .cache/

build.hl — konfiguracja

using <gen 2>

;; Docelowy format wyjściowy
% BIT_BUILD_TARGET = bc     # bc | elf | so

;; Główny plik wejściowy
% BIT_BUILD_INPUT = main.hl

;; Opcjonalna nazwa wyjściowa
% BIT_BUILD_OUTPUT = moj_program

Repozytorium pakietów

Format repo-list.json:

{
  "hashlib": {
    "type": "git",
    "family": "github",
    "url": "HackerOS-Linux-System/hashlib-bit.git",
    "description": "Kryptografia: sha256, md5, blake3"
  },
  "obsidian": {
    "type": "git",
    "family": "github",
    "url": "Bytes-Repository/obsidian-lib.git",
    "description": "GUI dialogi dla HL"
  }
}

Typy pakietów: git (github/gitlab), tar (archiwum), link (binarka)

System Genów

Gen Status Opis

gen 1

aktywny

Podstawowa składnia, &, >, _N, <<, :, :*, --

gen 2 (domyślny)

aktywny

Typowane zmienne (%: typ), $(), |>, @ in, ?~, ? switch, ||

gen 3

zarezerwowany

Domknięcia (planowane)

Deklaracja genu (opcjonalna — domyślnie gen 2):

#!/usr/bin/env hl
using <gen 2>

Przykłady

Hello World

#!/usr/bin/env hl
using <gen 2>

% name: str = HackerOS
~> Witaj, @name!

Skrypt systemowy z arytmetyką

#!/usr/bin/env hl
using <gen 2>

# <main/sys>
# <main/colors>

> uname -r |> @kernel
> nproc     |> @cores
$( @cores * 2 ) -> @threads

~> @COLOR_BOLD System Info: @COLOR_RESET
~> Kernel:  @kernel
~> Cores:   @cores
~> Threads: @threads

For-in z switch

using <gen 2>

% tools = "curl git nmap python3"
@ tool in @tools
    ::which @tool
    ? ok
        ::green ✓ @tool
    done
    ? err
        ::red   ✗ @tool
    done
done

While loop

using <gen 2>

% i: int = 0

?~ @i < 5
    $( @i + 1 ) -> @i
    ~> iteracja: @i
done

Switch

using <gen 2>

> uname -s |> @os

? switch @os
| Linux
    ::green Linux wykryty
| Darwin
    ::cyan  macOS wykryty
| *
    ~> Nieznany OS: @os
done

Goroutines

using <gen 2>

:** wyniki

:* scanner def
    > nmap -sn 192.168.1.0/24
    *-- wyniki
done

:* pinger def
    > ping -c 3 8.8.8.8
    *-- wyniki
done

*-- wyniki

HackerOS API

using <gen 2>

|| hacker update
|| hpkg install nmap
|| lpm list

Powłoka

HL może działać jako powłoka systemowa:

hl shell                # uruchom powłokę
hl shell -c "~> test"   # jednorazowa komenda

Plik konfiguracyjny ~/.hlrc:

using <gen 2>

=> EDITOR = nvim
=> PATH [
| /usr/local/bin
| /usr/bin
| /usr/lib/HackerOS
]

: ll def
    > ls -la
done

Builtiny powłoki: cd, vars, funcs, help, clear, exit

Linter i diagnostyka

HL posiada wbudowany linter w stylu Rust — z numerami linii i sugestiami:

error: `echo` jest zabronione w blokach komend HL
  --> skrypt.hl:5:1
 5 │ > echo hello
   ^^^^^^^^^^^
  help: zamień na: `~> hello`

warning: `> sudo cmd` — użyj operatora `^>`
  --> skrypt.hl:8:1
  help: zamień na: `^> cmd`

Automatycznie wykrywa: echo w >, sudo zamiast ^>, % PATH zamiast ⇒, brakujące deklaracje // dla narzędzi sieciowych.

Pliki i rozszerzenia

Rozszerzenie Opis

.hl

Kod źródłowy Hacker Lang

.bc

Bytecode HL (binarny IR + shebang, wykonywalny bezpośrednio)

.hlrc

Konfiguracja powłoki (~/.hlrc)

.hk

Format konfiguracyjny HackerOS (parsowany przez main/hk-parser)

.hacker

Format metadanych HackerOS v1/v2/v3 (parsowany przez main/hacker)

Testy

# Uruchom wszystkie testy
hl run tests/test_runner.hl

# Testy bytecode/JIT
hl run tests/bytecode_basics.hl

# Testy arytmetyki JIT
hl run tests/jit_arithmetic.hl

# Testy wydajności
hl run tests/performance.hl

# Testy pipeline kompilatora
hl run tests/compiler_pipeline.hl

# Testy zarządzania cache
hl run tests/cache_management.hl

Licencja i autorzy

Hacker Lang jest częścią projektu HackerOS.

Library index for Hacker Lang is bit.io: https://github.com/bit-io

About

Simple and fast HackerOS programming language for scripting and automation.

hackeros-linux-system.github.io/HackerOS-Website/hacker-lang/docs.html

Topics

rust rust-lang hackeros hackeros-debian hackeros-cli-tools hacker-lang

Resources

Readme

License

MPL-2.0 license
Activity
Custom properties

Stars

1 star

Watchers

0 watching

Forks

0 forks
Report repository

Releases 5

gen 1 Latest
May 4, 2026
+ 4 releases

Packages

 
 
 

Contributors

Languages