OnixOS - User contributions [en]

Category talk:O Language

2026-08-25T07:36:53Z

Tedaryum: Created blank page

Category:O Language

2026-08-25T07:36:33Z

Tedaryum: Protected "Category:O Language" ([Edit=Allow only administrators] (indefinite) [Move=Allow only administrators] (indefinite))

Category talk:Programming languages

2026-08-25T07:36:22Z

Tedaryum: Created blank page

Category:Programming languages

2026-08-25T07:36:17Z

Tedaryum: Created blank page

Category:O Language

2026-08-25T07:35:12Z

Tedaryum: Created blank page

OnixOS:Building From Scratch

2026-08-25T07:33:51Z

Tedaryum: Protected "OnixOS:Building From Scratch" ([Edit=Allow only administrators] (indefinite) [Move=Allow only administrators] (indefinite))

= Building From Scratch =

This document covers the complete build lifecycle of the OnixOS Build System — from environment setup and package repository builds to ISO creation, syncing, Docker-based builds, and live build monitoring.

__TOC__

== Prerequisites ==

The build system runs on '''Arch Linux''' (or an Arch-based environment). The following packages are required for ISO builds and are installed automatically by <code>build.py</code>:

{| class="wikitable"
! Package !! Purpose
|-
| <code>archiso</code> || Core ISO creation tool (<code>mkarchiso</code>)
|-
| <code>base-devel</code> || Compiler toolchain
|-
| <code>devtools</code> || <code>makechrootpkg</code>, <code>mkarchroot</code> for isolated chroot builds
|-
| <code>arch-install-scripts</code> || <code>pacstrap</code>, <code>arch-chroot</code>
|-
| <code>squashfs-tools</code> || SquashFS filesystem creation
|-
| <code>dosfstools</code> || FAT filesystem creation
|-
| <code>syslinux</code> || Bootloader
|-
| <code>git</code> / <code>git-lfs</code> || Source fetching
|-
| <code>rsync</code> || File synchronisation
|-
| <code>go</code> || Go language toolchain
|-
| <code>nasm</code> || Assembler
|-
| <code>ninja</code> || Build system
|-
| <code>gperf</code> || Hash function generator
|-
| <code>imagemagick</code> || Image processing
|-
| <code>python-sphinx</code> / <code>xmlto</code> || Documentation toolchain
|-
| <code>gnome-shell</code> / <code>qtcreator</code> || Desktop environment build deps
|-
| <code>gnupg</code> || GPG package signing
|-
| <code>qemu-user-static</code> || Cross-architecture emulation (ARM builds on x86_64 host)
|-
| <code>binfmt-support</code> || Binary format registration for qemu-user-static
|-
| <code>sudo</code> || Privilege escalation
|}

For '''repository builds''' the system additionally uses <code>makepkg</code> (included in <code>base-devel</code>) and the AUR snapshot endpoint:

https://aur.archlinux.org/cgit/aur.git/snapshot

== Project Structure ==

<pre>
onix-build-system/
├── build.py # Main build entry point
├── clean.py # Cleans output/ and mounts
├── watcher.py # Terminal build status monitor
├── qemu.py # Launch built ISO in QEMU
├── Makefile # Convenience make targets
├── buildkit-docker/
│ ├── Dockerfile # Build container image
│ ├── entrypoint.sh # Docker entrypoint (chroot bootstrap)
│ ├── conf/
│ │ └── makepkg.conf # Generic x86-64 baseline CFLAGS
│ ├── docker-compose.yml # Dev shell container
│ ├── docker-compose.iso.yml # Automated ISO build container
│ └── docker-compose.repos.yml # Automated repo build container
├── onixos/
│ ├── archconfig.py # Multiarch configuration (CFLAGS, chroot, qemu)
│ ├── iso.py # ISO build logic (mkarchiso wrapper)
│ ├── pkgbuild.py # PKGBUILD / .SRCINFO parser
│ ├── proc.py # Subprocess wrapper with logging
│ └── repository.py # Repository build logic (chroot, sanitize, sign)
├── sources/
│ ├── packages/ # Local package sources (PKGBUILD)
│ ├── profiles/ # archiso profiles (core, gnome, xfce, icewm, security, kurumsal, odesk)
│ ├── packages.list # Local packages to build
│ ├── aur.list # AUR packages to build
│ ├── profiles.list # ISO profiles to build
│ ├── signing.conf # GPG signing configuration (example)
│ ├── sync/ # Repo upload config
│ │ ├── sourceforge.conf
│ │ └── local.conf
│ └── isosync/ # ISO upload config
│ ├── sourceforge.conf
│ └── local.conf
├── output/ # All build artefacts (generated, per-arch)
└── logs/ # Build logs (generated, per-arch)
</pre>

== Build Commands ==

All commands must be run from the '''repository root'''.

=== Full Build ===

Builds all repositories '''and''' all ISO profiles in sequence:

sudo python build.py

=== Repository Build ===

Builds the <code>onix-base</code> (local packages) and <code>onix-aur</code> (AUR packages) repositories for '''all supported architectures''' by default:

python build.py repos

To build for a '''specific architecture''':

python build.py repos --arch=x86_64_v3

The build process per architecture:
# Bootstraps a clean chroot with <code>base-devel</code> (isolated from host system).
# Generates architecture-specific <code>makepkg.conf</code> inside the chroot (generic CFLAGS baseline).
# Sanitizes PKGBUILD files to prevent instruction leakage (<code>-march=native</code> → architecture baseline).
# Builds packages using <code>makechrootpkg -c -r <chroot></code> (host isolation, dependency resolution inside chroot).
# Signs each <code>.pkg.tar.zst</code> with GPG detach-signature (if signing key is configured).
# Generates repository database with <code>repo-add</code>.

'''Supported architectures:'''

{| class="wikitable"
! Architecture !! CFLAGS Baseline !! Description !! QEMU Required
|-
| <code>x86_64</code> || <code>-march=x86-64</code> || Generic x86-64 (2004+, all CPUs) || No
|-
| <code>x86_64_v2</code> || <code>-march=x86-64-v2</code> || SSE4.2, POPCNT (2008+: Nehalem, Bulldozer) || No
|-
| <code>x86_64_v3</code> || <code>-march=x86-64-v3</code> || AVX, AVX2, BMI1/2, FMA (2015+: Haswell, Zen) || No
|-
| <code>i686</code> || <code>-march=i686</code> || 32-bit x86 (Pentium Pro+) || No
|-
| <code>aarch64</code> || <code>-march=armv8-a</code> || 64-bit ARM (ARMv8-A) || Yes
|-
| <code>armv7h</code> || <code>-march=armv7-a -mfloat-abi=hard</code> || 32-bit ARM hard-float (ARMv7-A) || Yes
|-
| <code>armv6h</code> || <code>-march=armv6 -mfloat-abi=hard</code> || 32-bit ARM hard-float (ARMv6, Raspberry Pi 1) || Yes
|}

{{Note|ARM architectures require <code>qemu-user-static</code> and <code>binfmt-support</code> for cross-architecture emulation. The Docker image includes these packages.}}

=== ISO Build ===

Builds ISO images for '''all ISO-supported architectures''' (x86_64 and aarch64) and every profile listed in <code>sources/profiles.list</code>:

sudo python build.py iso

To build for a '''specific architecture''':

sudo python build.py iso --arch=aarch64

To build '''without chroot isolation''' (direct <code>mkarchiso</code> invocation, useful for debugging):

sudo python build.py iso --no-chroot

The build process per profile per architecture:
# Installs ISO build dependencies via <code>pacman</code>.
# Creates a '''staging copy''' of the profile with architecture-specific overrides:
#* Rewrites <code>profiledef.sh</code> with the target architecture and boot modes.
#* Selects <code>packages.<arch></code> as the package list.
#* Generates architecture-specific <code>pacman.conf</code> (with <code>$arch</code> repo URLs).
#* Removes <code>syslinux/</code> for aarch64 (UEFI-only).
# When '''chroot isolation''' is enabled (default):
## Bootstraps a clean chroot with <code>base-devel</code>, <code>archiso</code>, <code>squashfs-tools</code>, <code>dosfstools</code>, and <code>arch-install-scripts</code>.
## Bind-mounts <code>/proc</code>, <code>/sys</code>, <code>/dev</code>, <code>/dev/pts</code>, source profile, work directory, and output directory into the chroot.
## Runs <code>mkarchiso</code> inside the chroot with sanitized environment variables.
## Unmounts all bind mounts (deepest first) on exit, error, or signal (SIGINT/SIGTERM).
# When '''chroot isolation''' is disabled (<code>--no-chroot</code>):
## Unmounts any stale mounts from a previous failed build.
## Cleans the work directory.
## Runs <code>mkarchiso</code> directly on the host.
# Writes the finished <code>.iso</code> file to <code>output/iso/<profile>/<arch>/output/</code>.

'''ISO-supported architectures:'''

{| class="wikitable"
! Architecture !! Boot Modes !! Syslinux !! Notes
|-
| <code>x86_64</code> || BIOS (syslinux) + UEFI (systemd-boot) || Yes || Standard x86-64 ISO
|-
| <code>aarch64</code> || UEFI only (systemd-boot) || No || ARM64, excludes x86-only packages (microcode, video drivers)
|}

{{Note|The aarch64 ISO excludes packages that are x86-specific: <code>amd-ucode</code>, <code>intel-ucode</code>, <code>memtest86+</code>, <code>syslinux</code>, <code>broadcom-wl</code>, <code>b43-fwcutter</code>, x86-only video drivers (<code>xf86-video-*</code>), and <code>edk2-shell</code>.}}

=== Upload / Sync ===

Uploads built repositories to the configured remote server(s):

python build.py upload

Uploads built ISO images:

python build.py iso-sync

Both commands read from the relevant <code>*.conf</code> files under <code>sources/sync/</code> and <code>sources/isosync/</code> respectively (see [[#Sync Configuration|Sync Configuration]]).

== Make Targets ==

=== Core Build Targets ===

<pre>
make # clean → repos → iso (full build, all architectures)
make clean # Remove output artefacts and unmount
make repos # Repository build for all architectures
make repos ARCH=x86_64_v3 # Repository build for specific architecture
make iso # ISO build for all architectures (x86_64 + aarch64)
make iso ARCH=x86_64 # ISO build for specific architecture
make iso-all # ISO build for all architectures (explicit)
make iso-nochroot # ISO build without chroot isolation
make iso-nochroot ARCH=aarch64 # ISO build without chroot for specific architecture
</pre>

=== Chroot Management ===

<pre>
make chroot_bootstrap # Bootstrap chroots for all architectures
make chroot_bootstrap ARCH=x86_64 # Bootstrap chroot for specific architecture
make chroot_clean # Remove all chroots
make chroot_clean ARCH=x86_64 # Remove chroot for specific architecture
make chroot_shell ARCH=x86_64 # Spawn shell inside chroot (requires ONIX_CHROOT)
</pre>

=== Testing ===

<pre>
make test # Run all tests for all architectures
make test ARCH=x86_64_v3 # Run all tests for specific architecture
make test-march # Verify -march baseline in compiled binaries
make test-sign # Verify GPG signatures
make test-deps # Check for missing shared-object dependencies
make test-sanitize # Verify PKGBUILD sanitizer rewrites flags
make test-smoke # End-to-end smoke test (build single package)
</pre>

=== Docker Targets ===

<pre>
make docker_build # Build the Docker image
make docker_publish # Push image to registry (olproject/buildkit)
make docker_pull # Pull image from registry
make docker_shell # Open interactive shell in container

make docker_iso_build # Run ISO build inside Docker for all architectures
make docker_iso_build ARCH=aarch64 # Run ISO build for specific architecture
make docker_repo_build # Run repo build inside Docker for all architectures
make docker_repo_build ARCH=aarch64 # Run repo build for specific architecture
make docker_test # Build repos in Docker, then run tests locally
</pre>

=== Environment Variables ===

{| class="wikitable"
! Variable !! Default !! Description
|-
| <code>ARCH</code> || (all) || Target architecture for make targets
|-
| <code>ONIX_ARCH</code> || <code>x86_64</code> || Architecture (used by entrypoint.sh and docker-compose)
|-
| <code>ONIX_CHROOT</code> || (auto) || Explicit chroot path for repo builds (Jenkins per-build)
|-
| <code>ONIX_ISO_CHROOT</code> || (auto) || Explicit chroot path for ISO builds
|-
| <code>ONIX_CHROOT_PREFIX</code> || <code>/tmp/onix-chroot</code> || Chroot path prefix (auto-suffix with arch+pid+ts)
|-
| <code>ONIX_SIGN_KEY</code> || (default key) || GPG key ID / email for signing
|-
| <code>ONIX_GPG_PASSPHRASE</code> || (none) || GPG passphrase for batch mode
|}

== Docker Builds ==

The Docker image is based on <code>archlinux</code> and ships with all build dependencies pre-installed, including <code>devtools</code> (for <code>makechrootpkg</code>), <code>qemu-user-static</code> (for ARM emulation), and <code>gnupg</code> (for package signing). The image tag is <code>olproject/buildkit</code>. All Docker-related files are located under <code>buildkit-docker/</code>.

=== Building the Image ===

<pre>
docker build -f buildkit-docker/Dockerfile . -t olproject/buildkit
# or via make:
make docker_build
</pre>

The Dockerfile installs:
* <code>base-devel</code>, <code>devtools</code> — compiler toolchain and <code>makechrootpkg</code>
* <code>qemu-user-static</code>, <code>binfmt-support</code> — ARM cross-architecture emulation
* <code>gnupg</code> — GPG package signing
* <code>makepkg.conf</code> with generic x86-64 baseline CFLAGS

=== ISO Build via Docker ===

Builds ISO images for '''all ISO-supported architectures''' by default:

<pre>
make docker_iso_build
</pre>

To build for a '''specific architecture''':

<pre>
make docker_iso_build ARCH=aarch64
</pre>

The make target automatically:
# Runs the Docker container with <code>ONIX_ARCH</code> set.
# Copies <code>output/</code> and <code>logs/</code> from the container.
# Removes the container.
# Iterates over all ISO architectures if no <code>ARCH</code> is specified.

The container entrypoint (<code>entrypoint.sh</code>) automatically:
# Resolves the chroot directory (from <code>ONIX_CHROOT</code> or generates dynamic path).
# Tears down any existing chroot and bootstraps a clean one with <code>mkarchroot</code>.
# Ensures <code>GNUPGHOME</code> directory exists.
# Passes <code>--arch</code> parameter to <code>python build.py iso</code>.

=== Repository Build via Docker ===

Builds repositories for '''all architectures''' by default:

<pre>
docker-compose -f buildkit-docker/docker-compose.repos.yml up --abort-on-container-exit --build
docker cp buildkit:/home/buildkit/builder/output/. ./output/
docker cp buildkit:/home/buildkit/builder/logs/. ./logs/
docker rm buildkit
# or via make:
make docker_repo_build
</pre>

To build for a '''specific architecture''':

<pre>
ONIX_ARCH=x86_64_v3 docker-compose -f buildkit-docker/docker-compose.repos.yml up --abort-on-container-exit --build
# or via make:
make docker_repo_build ARCH=x86_64_v3
</pre>

The container entrypoint (<code>entrypoint.sh</code>) automatically:
# Resolves the chroot directory (from <code>ONIX_CHROOT</code> or generates dynamic path).
# Tears down any existing chroot and bootstraps a clean one with <code>mkarchroot</code>.
# Ensures <code>GNUPGHOME</code> directory exists.
# Passes <code>--arch</code> parameter to <code>python build.py repos</code> or <code>python build.py iso</code>.

=== Interactive Shell ===

Starts a persistent container with output and logs mounted as volumes, useful for manual inspection or debugging:

<pre>
docker-compose -f buildkit-docker/docker-compose.yml up -d
docker exec -it buildkit bash
# or via make:
make docker_shell
</pre>

The container mounts:
* <code>./output/</code> → <code>/home/buildkit/builder/output</code>
* <code>./logs/</code> → <code>/home/buildkit/builder/logs</code>
* <code>gnupg</code> volume → <code>/gnupg</code> (GPG keyring)

{{Note|The container runs in <code>--privileged</code> mode, which is required by <code>mkarchiso</code> for loop device and mount operations, and by <code>makechrootpkg</code> for chroot operations.}}

== Profiles ==

ISO profiles are listed in <code>sources/profiles.list</code>, one per line. Each profile corresponds to a directory under <code>sources/profiles/</code> that contains a complete <code>archiso</code> profile.

Each profile directory contains architecture-specific files:

{| class="wikitable"
! File !! Purpose
|-
| <code>profiledef.sh</code> || ISO metadata (name, label, version, boot modes, arch) — '''rewritten at build time''' for target architecture
|-
| <code>pacman.conf</code> || Pacman config for ISO build (with <code>$arch</code> repo URLs)
|-
| <code>pacman.aarch64.conf</code> || Pacman config for aarch64 (no multilib, <code>Architecture = aarch64</code>)
|-
| <code>packages.x86_64</code> || Package list for x86_64
|-
| <code>packages.aarch64</code> || Package list for aarch64 (excludes x86-only packages)
|-
| <code>airootfs/</code> || Files to overlay onto the ISO root filesystem
|-
| <code>syslinux/</code> || Syslinux bootloader configs (x86_64 only, removed for aarch64)
|-
| <code>efiboot/</code> || EFI boot files (per-architecture entries)
|}

Available profiles:

[Profiles are now maintained in an external repository](https://gitlab.com/onix-os/onixos-profiles). The repository contains the same profile directories as before. You can clone it and point the build system to the directory.

{| class="wikitable"
! Profile !! Description
|-
| <code>core</code> || Minimal base system
|-
| <code>gnome</code> || GNOME desktop environment
|-
| <code>xfce</code> || Xfce desktop environment
|-
| <code>icewm</code> || IceWM lightweight desktop
|-
| <code>security</code> || Security-focused variant
|-

|-
| <code>odesk</code> || Office desktop environment
|}



To build only a specific profile, edit <code>sources/profiles.list</code> temporarily or call <code>ISO.mkarchiso()</code> directly.

== Packages ==

=== Local Packages (onix-base) ===

Defined in <code>sources/packages.list</code>. Sources live under <code>sources/packages/<name>/</code>:

{| class="wikitable"
! Package !! Purpose
|-
| <code>olang</code> || OnixOS language runtime
|-
| <code>onix-base</code> || Base system metapackage
|-
| <code>onix-graphics</code> || Graphics stack
|-
| <code>onix-meta</code> || Meta package
|-
| <code>calamares-onix</code> || Graphical installer (Qt6, git source, with branding)
|-
| <code>linux-onix-zen</code> || OnixOS ZEN kernel (7.1.7-zen1)
|-
| <code>linux-onix-rt</code> || OnixOS real-time kernel
|-
| <code>linux-onix-generic</code> || OnixOS generic kernel (Arch mainline 7.1.7.arch1)
|-
| <code>plymouth-onix-boot</code> || Boot splash screen
|-
| <code>openxenmanager</code> || Xen hypervisor management tool
|-
| <code>onix-updater</code> || OnixOS system updater
|-
| <code>mkinitcpio-openswap</code> || Encrypted swap support for mkinitcpio
|-
| <code>ckbcomp</code> || Keyboard composition utility
|}

=== External Packages Repository ===

The package definitions have been moved to an external repository:

[OnixOS Packages Repository](https://gitlab.com/onix-os/onixos-packages)

You can clone this repository and refer to it for package sources.

=== AUR Packages (onix-aur) ===

Defined in <code>sources/aur.list</code>. Downloaded from the AUR snapshot endpoint at build time. Output goes to <code>output/aur/</code>.

== Sync Configuration ==

Both repository and ISO sync use SSH (<code>rsync</code> over SSH). Configuration files follow the standard <code>configparser</code> INI format.

=== Repository Sync ===

Config files read by <code>build.py upload</code> (both are used if they exist):
* <code>sources/sync/sourceforge.conf</code> — SourceForge remote
* <code>sources/sync/local.conf</code> — Local/internal server

Example:

<pre>
[sync]
server = frs.sourceforge.net
user = olproject
path = /home/frs/project/onixos/Repo
port = 22
keyfile = /home/ted/.ssh/id_ed25519
</pre>

Uploads <code>output/base/<arch>/repo</code> → <code><path>/base/<arch></code> and <code>output/aur/<arch>/repo</code> → <code><path>/aur/<arch></code> for each architecture.

Example remote structure:

<pre>
/home/frs/project/onixos/Repo/
├── base/
│ ├── x86_64/
│ │ ├── onix-base.db.tar.gz
│ │ ├── package1.pkg.tar.zst
│ │ └── package1.pkg.tar.zst.sig
│ ├── x86_64_v2/
│ ├── x86_64_v3/
│ ├── i686/
│ ├── aarch64/
│ ├── armv7h/
│ └── armv6h/
└── aur/
├── x86_64/
├── x86_64_v2/
└── ...
</pre>

=== ISO Sync ===

Config files read by <code>build.py iso-sync</code>:
* <code>sources/isosync/sourceforge.conf</code>
* <code>sources/isosync/local.conf</code>

Uploads <code>output/iso/<profile>/<arch>/output</code> → <code><path>/ISO/<arch></code> for each profile and architecture.

Example remote structure:

<pre>
/home/frs/project/onixos/Daily/ISO/
├── x86_64/
│ ├── onixos-core-*.iso
│ ├── onixos-gnome-*.iso
│ ├── onixos-xfce-*.iso
│ ├── onixos-icewm-*.iso
│ └── onixos-security-*.iso
└── aarch64/
├── onixos-core-*.iso
├── onixos-gnome-*.iso
└── ...
</pre>

== Debug Mode ==

Append <code>-d</code> to <code>iso</code> or <code>repos</code> subcommands to stream <code>stdout</code>/<code>stderr</code> to the terminal in real time:

<pre>
sudo python build.py iso -d
sudo python build.py iso --arch=aarch64 -d
python build.py repos -d
python build.py repos --arch=x86_64_v3 -d
</pre>

Without <code>-d</code>, command output is only written to the log files in <code>logs/<arch>/</code>.

== Build Watcher ==

<code>watcher.py</code> provides a live terminal dashboard that tracks ISO and repository build status, active mounts, and recent log output. It refreshes every 3 seconds.

'''Standalone (curses UI):'''

python watcher.py

Press <code>q</code> or <code>Esc</code> to exit.

'''Attached to a build (GUI overlay):'''

<pre>
sudo python build.py iso -gui
python build.py repos -gui
</pre>

The <code>-gui</code> flag starts the watcher in a background thread alongside the build process and stops it automatically when the build finishes.

'''What the watcher shows:'''
* '''ISO Builds''' — profile name, ISO filename, file size, build timestamp, architecture, and status. Scans per-arch directories (<code>output/iso/<profile>/<arch>/output/</code>).
* '''Repositories''' — repo name, total package count across all architectures, DB update timestamp, and status. Scans per-arch directories (<code>output/base/<arch>/repo/</code>).
* '''Active Mounts''' — any loop/overlay mounts still active inside <code>output/</code>.
* '''Last Build Log''' — last 6 lines of <code>logs/isobuild.log</code> with colour-coded errors and warnings.

== Testing with QEMU ==

Launch a built ISO in a QEMU virtual machine for quick validation:

python qemu.py <path-to-iso> [--arch=<arch>]

Examples:

<pre>
python qemu.py output/iso/gnome/x86_64/output/onixos-gnome-x86_64.iso
python qemu.py output/iso/core/aarch64/output/onixos-core-aarch64.iso --arch=aarch64
</pre>

VM parameters:

{| class="wikitable"
! Parameter !! x86_64 !! aarch64
|-
| Binary || <code>qemu-system-x86_64</code> || <code>qemu-system-aarch64</code>
|-
| Machine || (default) || <code>virt</code>
|-
| CPU || <code>x86_64</code> || <code>cortex-a57</code>
|-
| RAM || 4 GB || 4 GB
|-
| Cores || 1 || 1
|-
| VGA || qxl || virtio-gpu-pci
|-
| Network || User-mode (NAT) || User-mode (NAT)
|-
| Boot || CD-ROM || CD-ROM
|}

<code>qemu-system-x86_64</code> or <code>qemu-system-aarch64</code> must be installed and available in <code>PATH</code>.

== Cleaning the Build ==

Removes all build artefacts, clears the pacman package cache, unmounts any stale mounts, and deletes log files:

<pre>
sudo python clean.py
# or via make:
make clean
</pre>

What <code>clean.py</code> does in order:
# Reads <code>/proc/mounts</code> and unmounts (with <code>umount -l</code>) anything mounted inside <code>output/</code>, deepest paths first.
# Clears the pacman package cache: <code>find /var/cache/pacman/pkg/ -name '*.pkg.tar.*' -delete</code>.
# Removes all <code>logs/*.log</code> files.
# Removes all contents of <code>output/</code> with <code>sudo rm -rfv output/*</code>.

{{Warning|This is destructive. All previously built ISOs and repository packages will be deleted.}}

To remove only the chroot directories (without touching output):

<pre>
make chroot_clean
# or for a specific architecture:
make chroot_clean ARCH=x86_64_v3
</pre>

== Isolated Chroot Build ==

Repository builds use <code>makechrootpkg</code> from the <code>devtools</code> package to compile packages in an '''isolated chroot environment'''. ISO builds use a similar chroot isolation approach with <code>mkarchiso</code>. This prevents:

# '''Host pollution''' — packages cannot accidentally link against host libraries not listed in <code>makedepends</code>.
# '''Instruction leakage''' — packages are compiled with generic CFLAGS baseline, not host-specific optimizations.
# '''Non-reproducible builds''' — the build environment is deterministic and isolated from host updates.

=== Repository Chroot Lifecycle ===

# '''Bootstrap''': <code>mkarchroot <chroot>/root base-devel</code> creates a minimal Arch Linux root filesystem.
# '''Build''': <code>makechrootpkg -c -r <chroot></code> builds the package inside the chroot. The <code>-c</code> flag creates a copy-on-write snapshot, so the base chroot remains clean.
# '''Cleanup''': After each build, the snapshot is discarded. The base chroot persists for reuse.

=== ISO Chroot Lifecycle ===

# '''Bootstrap''': <code>mkarchroot <chroot>/root base-devel archiso squashfs-tools dosfstools arch-install-scripts</code> creates a chroot with all ISO build tools.
# '''Mount''': Bind-mounts virtual filesystems and directories into the chroot:
#* <code>/proc</code> → <code>chroot/root/proc</code>
#* <code>/sys</code> → <code>chroot/root/sys</code>
#* <code>/dev</code> → <code>chroot/root/dev</code>
#* <code>/dev/pts</code> → <code>chroot/root/dev/pts</code>
#* Staging profile directory → <code>chroot/root/src</code>
#* Work directory → <code>chroot/root/work</code>
#* Output directory → <code>chroot/root/out</code>
# '''Build''': <code>chroot <chroot>/root /usr/bin/env -i PATH=... mkarchiso ...</code> runs inside the chroot with sanitized environment.
# '''Cleanup''': All bind mounts are unmounted (deepest first) on exit, error, or signal (SIGINT/SIGTERM). Mount cleanup is guaranteed via <code>try/finally</code>.

{{Note|ISO chroot isolation can be disabled with <code>--no-chroot</code> for debugging or when running in an already-isolated environment (e.g., Docker).}}

=== Dynamic Chroot Path ===

The chroot directory is resolved dynamically per architecture:

'''Repository builds:'''
# '''Explicit''': <code>ONIX_CHROOT</code> environment variable (Jenkins per-build isolation).
# '''Prefix-based''': <code>ONIX_CHROOT_PREFIX</code> + architecture + PID + timestamp (workspace-aware).
# '''Auto-generated''': <code>/tmp/onix-chroot-<arch>-<pid>-<timestamp></code> (unique per process).

'''ISO builds:'''
# '''Explicit''': <code>ONIX_ISO_CHROOT</code> environment variable.
# '''Prefix-based''': <code>ONIX_CHROOT_PREFIX</code> + architecture + PID + timestamp.
# '''Auto-generated''': <code>/tmp/onix-iso-chroot-<arch>-<pid>-<timestamp></code> (unique per process).

Example for Jenkins:

<pre>
export ONIX_CHROOT="/var/lib/jenkins/onix-chroot-${BUILD_NUMBER}"
python build.py repos
</pre>

=== Manual Chroot Management ===

Bootstrap chroots for all architectures:

<pre>
make chroot_bootstrap
</pre>

Bootstrap a specific architecture:

<pre>
make chroot_bootstrap ARCH=aarch64
</pre>

Spawn a shell inside a chroot (requires <code>ONIX_CHROOT</code> to be set):

<pre>
export ONIX_CHROOT=/tmp/onix-chroot
make chroot_bootstrap ARCH=x86_64
make chroot_shell ARCH=x86_64
</pre>

== PKGBUILD Sanitization ==

Before building each package, the build system '''sanitizes''' the <code>PKGBUILD</code> file to prevent instruction leakage:

# Searches for hardcoded <code>-march=native</code>, <code>-march=haswell</code>, <code>-mavx2</code>, etc.
# Rewrites them to the architecture-specific baseline (e.g., <code>-march=x86-64</code> for <code>x86_64</code>).
# Strips explicit AVX/SSE4 feature flags (<code>-mavx</code>, <code>-mfma</code>, <code>-msse4.2</code>).
# Backs up the original <code>PKGBUILD</code> to <code>PKGBUILD.bak</code> (idempotent — only first run).

This ensures packages compiled on a modern build server (e.g., with AVX-512) will run on older CPUs without triggering <code>Illegal instruction</code> errors.

=== Sanitization Patterns ===

{| class="wikitable"
! Pattern !! Replacement (x86_64) !! Replacement (x86_64_v3)
|-
| <code>-march=native</code> || <code>-march=x86-64</code> || <code>-march=x86-64-v3</code>
|-
| <code>-march=haswell</code> || <code>-march=x86-64</code> || <code>-march=x86-64-v3</code>
|-
| <code>-march=skylake</code> || <code>-march=x86-64</code> || <code>-march=x86-64-v3</code>
|-
| <code>-mtune=native</code> || <code>-mtune=generic</code> || <code>-mtune=generic</code>
|-
| <code>-mavx2</code> || (removed) || (removed)
|-
| <code>-mfma</code> || (removed) || (removed)
|-
| <code>-msse4.2</code> || (removed) || (removed)
|}

=== Verification ===

Test the sanitizer with a synthetic PKGBUILD:

<pre>
make test-sanitize ARCH=x86_64
</pre>

== GPG Signing ==

Each built package is signed with a GPG detach-signature before being added to the repository database.

=== Signing Configuration ===

Create <code>sources/signing.conf</code> (example):

<pre>
[sign]
key_id = "FINGERPRINT_OR_EMAIL_OF_SIGNING_KEY"
passphrase_env = "ONIX_GPG_PASSPHRASE"
</pre>

=== Key Setup ===

Import the private key into the GPG keyring:

<pre>
export GNUPGHOME=/gnupg # or ~/.gnupg for local builds
gpg --import <private-key.asc>
gpg --edit-key <key_id>
> trust
> 5
> save
</pre>

=== Environment Variables ===

{| class="wikitable"
! Variable !! Description
|-
| <code>GNUPGHOME</code> || Path to GPG keyring directory (default: <code>/gnupg</code> in Docker)
|-
| <code>ONIX_SIGN_KEY</code> || GPG key ID or email to use with <code>--local-user</code>
|-
| <code>ONIX_GPG_PASSPHRASE</code> || Passphrase for the signing key (batch mode with <code>--pinentry-mode loopback</code>)
|}

=== Verification ===

Verify signatures on built packages:

<pre>
make test-sign ARCH=x86_64
</pre>

== Testing ==

The build system includes a comprehensive test suite to verify package integrity.

=== Test Targets ===

{| class="wikitable"
! Target !! Description
|-
| <code>make test</code> || Run all tests for all architectures
|-
| <code>make test ARCH=x86_64_v3</code> || Run all tests for specific architecture
|-
| <code>make test-march</code> || Verify compiled binaries use generic <code>-march</code> baseline (no instruction leakage)
|-
| <code>make test-sign</code> || Verify GPG signatures exist and validate
|-
| <code>make test-deps</code> || Check for missing shared-object dependencies (host makedepends leak detection)
|-
| <code>make test-sanitize</code> || Verify PKGBUILD sanitizer rewrites flags correctly
|-
| <code>make test-smoke</code> || End-to-end smoke test: build single package, verify integrity
|}

=== test-march ===

Inspects every ELF binary in built packages using <code>readelf -n</code> to verify the <code>march</code> value matches the architecture baseline. Fails if binaries were compiled with host-specific optimizations (e.g., <code>-march=skylake</code> on an <code>x86_64</code> build).

=== test-sign ===

Verifies that every <code>.pkg.tar.zst</code> file has a corresponding <code>.pkg.tar.zst.sig</code> file and that the signature validates against the GPG keyring.

=== test-deps ===

Extracts each package, runs <code>ldd</code> on ELF binaries, and checks for "not found" shared libraries. Detects cases where a package was compiled against host libraries not listed in <code>makedepends</code> (chroot isolation failure).

=== test-sanitize ===

Creates a synthetic <code>PKGBUILD</code> with instruction leakage (<code>-march=native</code>, <code>-mavx2</code>, etc.), runs the sanitizer, and verifies:
# Flags were rewritten to the architecture baseline.
# Original <code>PKGBUILD</code> was backed up to <code>PKGBUILD.bak</code>.
# No leaked flags remain in the sanitized file.

=== test-smoke ===

Builds a single small AUR package (e.g., <code>lolcat</code>) end-to-end in a fresh chroot, then runs <code>test-march</code> on the result. Useful as a fast CI gate before building the full ~1000-package list.

=== Example Test Run ===

<pre>
# Build repos for x86_64_v3
make repos ARCH=x86_64_v3

# Run all tests
make test ARCH=x86_64_v3

# Or run individual tests
make test-march ARCH=x86_64_v3
make test-sign ARCH=x86_64_v3
make test-deps ARCH=x86_64_v3
</pre>

== Output Structure ==

After a successful full build (all architectures):

<pre>
output/
├── base/
│ ├── x86_64/
│ │ └── repo/ # onix-base repository for x86_64
│ ├── x86_64_v2/
│ │ └── repo/ # onix-base repository for x86_64_v2
│ ├── x86_64_v3/
│ │ └── repo/ # onix-base repository for x86_64_v3
│ ├── i686/
│ │ └── repo/ # onix-base repository for i686
│ ├── aarch64/
│ │ └── repo/ # onix-base repository for aarch64
│ ├── armv7h/
│ │ └── repo/ # onix-base repository for armv7h
│ └── armv6h/
│ └── repo/ # onix-base repository for armv6h
├── aur/
│ ├── x86_64/
│ │ └── repo/ # onix-aur repository for x86_64
│ ├── x86_64_v2/
│ │ └── repo/
│ ├── x86_64_v3/
│ │ └── repo/
│ ├── i686/
│ │ └── repo/
│ ├── aarch64/
│ │ └── repo/
│ ├── armv7h/
│ │ └── repo/
│ └── armv6h/
│ └── repo/
└── iso/
├── core/
│ ├── x86_64/
│ │ ├── work/ # mkarchiso working directory (temporary)
│ │ └── output/ # core-*.iso (x86_64)
│ └── aarch64/
│ ├── work/
│ └── output/ # core-*.iso (aarch64)
├── gnome/
│ ├── x86_64/
│ │ ├── work/
│ │ └── output/ # gnome-*.iso (x86_64)
│ └── aarch64/
│ ├── work/
│ └── output/ # gnome-*.iso (aarch64)
├── xfce/
│ ├── x86_64/
│ └── aarch64/
├── icewm/
│ ├── x86_64/
│ └── aarch64/
├── security/
│ ├── x86_64/
│ └── aarch64/
├── kurumsal/
│ ├── firewall/
│ │ ├── work/
│ │ └── output/ # kurumsal-firewall-*.iso
│ ├── server/
│ │ ├── work/
│ │ └── output/ # kurumsal-server-*.iso
│ └── desktop/
│ ├── work/
│ └── output/ # kurumsal-desktop-*.iso
└── odesk/
├── work/
└── output/ # odesk-*.iso
</pre>

Each repository directory contains:
* <code>*.pkg.tar.zst</code> — built packages
* <code>*.pkg.tar.zst.sig</code> — GPG detach-signatures
* <code>onix-base.db.tar.gz</code> or <code>onix-aur.db.tar.gz</code> — repository database
* <code>onix-base.files.tar.gz</code> or <code>onix-aur.files.tar.gz</code> — file list database

== Logs ==

Build logs are written to <code>logs/<arch>/</code> in the repository root (per-architecture):

<pre>
logs/
├── x86_64/
│ ├── chroot-bootstrap.log # mkarchroot output (repo builds)
│ ├── iso-chroot-bootstrap.log # mkarchroot output (ISO chroot)
│ ├── isobuild.log # mkarchiso output (ISO builds)
│ ├── pacinst.log # pacman dependency installation
│ ├── <package>.log # makechrootpkg output per package
│ ├── sign.log # GPG signing output
│ ├── repoadd.log # repo-add output
│ └── copy.log # package copy output
├── x86_64_v2/
│ └── ...
├── x86_64_v3/
│ └── ...
├── i686/
│ └── ...
├── aarch64/
│ ├── chroot-bootstrap.log
│ ├── iso-chroot-bootstrap.log
│ ├── isobuild.log
│ └── ...
├── armv7h/
│ └── ...
├── armv6h/
│ └── ...
└── clean.log # clean operation output
</pre>

Each log entry records the command, date/time, exit code, stderr, and stdout.

OnixOS:Repositories

2026-08-25T07:33:31Z

Tedaryum: Protected "OnixOS:Repositories" ([Edit=Allow only administrators] (indefinite) [Move=Allow only administrators] (indefinite))

== OnixOS Mirrors ==

You can install packages in repositories on your own Arch Linux-based system using Arch Linux repositories.

The pacman we mentioned at the bottom.you can use the conf and mirrorlist files under /etc/.

* [https://gitlab.com/onix-os/onix-build-system/-/blob/main/sources/profiles/core/pacman.conf pacman.conf]
* [https://gitlab.com/onix-os/onix-build-system/-/blob/main/sources/profiles/core/airootfs/etc/pacman.d/mirrorlist mirrorlist]

[onix-base]
SigLevel = Never
Server = http://repo.onix-project.com/base/
[onix-aur]
SigLevel = Never
Server = http://repo.onix-project.com/aur/

OnixOS:Package Management

2026-08-25T07:33:26Z

Tedaryum: Protected "OnixOS:Package Management" ([Edit=Allow only administrators] (indefinite) [Move=Allow only administrators] (indefinite))

''' pacman Usage Guide'''

''' pacman''' is the package manager for Arch Linux and its derivatives, designed to manage packages efficiently with simple commands.

== Installation ==
Pacman is included by default in Arch Linux. To ensure it is installed and up to date, run:

sudo pacman -Syu

== Basic Usage ==
=== Package Installation ===
To install a package, use:

sudo pacman -S <package_name>

For example, to install Firefox:
sudo pacman -S firefox

=== Package Removal ===
To remove a package:

sudo pacman -R <package_name>

To remove a package along with its dependencies:

sudo pacman -Rns <package_name>

=== System Update ===
To update all installed packages:

sudo pacman -Syu

To force a database refresh and then update:

sudo pacman -Syyu

== Package Management ==
=== Searching for Packages ===
To search for a package in the official repositories:

pacman -Ss <keyword>

To check if a package is installed:

pacman -Qs <package_name>

=== Package Information ===
To view package details:

pacman -Qi <package_name>

To list all installed packages:

pacman -Qe

== Cleaning Up ==
To remove orphaned dependencies:

sudo pacman -Rns $( pacman -Qdtq)

To clean the package cache:

sudo pacman -Sc

To remove all cached packages:

sudo pacman -Scc

== Troubleshooting ==
=== Fixing Key Issues ===
If a signature error occurs:

sudo pacman-key --init
sudo pacman-key --populate archlinux

To refresh keys:

sudo pacman-key --refresh-keys

=== Resolving Conflicts ===
If a file conflict error occurs, manually remove the conflicting file and retry:

sudo rm /path/to/conflicting/file
sudo pacman -Syu

== See Also ==
* [https://wiki.archlinux.org/title/ pacman Arch Linux pacman Wiki]
* [https://man.archlinux.org/man/ pacman.8 pacman Manual]

OnixOS:Getting Started

2026-08-25T07:33:17Z

Tedaryum: Protected "OnixOS:Getting Started" ([Edit=Allow only administrators] (indefinite) [Move=Allow only administrators] (indefinite))

== OnixOS: Getting Started ==

== Introduction ==

OnixOS Arch is a Linux-based and open source distribution. It comes with its own system-based functional programming language (O Language). It offers some customized tools for developers.

== System Requirements ==

Before getting started with OnixOS, make sure your system meets the following requirements:

=== Minimum Requirements ===
* 1 GHz Processor
* 1 GB RAM
* 5 GB Free Hard Drive Space
* Graphics: 1024x768 resolution display

=== Recommended Requirements ===
* Dual-core processor (2.0 GHz or higher)
* 2 GB RAM or more
* 10 GB Free Hard Drive Space
* Graphics: 1366x768 resolution or higher

O Language/API/System

2026-08-25T07:32:51Z

Tedaryum: Protected "O Language/API/System" ([Edit=Allow only administrators] (indefinite) [Move=Allow only administrators] (indefinite))

= System APIs =

System APIs connect O Language programs to the operating system and external services.

== Files and environment ==

Use <code>read</code>, <code>write</code>, <code>remove</code>, <code>mkdir</code>, <code>rmdir</code>, <code>finfo</code>, <code>chmod</code>, <code>exist</code>, <code>wdir</code>, and <code>chdir</code> for files and directories. Use <code>sysenv</code> to read environment values.

== Processes ==

Use <code>open</code>, <code>run</code>, <code>exec</code>, <code>sh_exec</code>, and <code>cmd_exec</code> to start commands. Use <code>proc_out</code>, <code>proc_pid</code>, and <code>proc_kill</code> to inspect or stop them.

== Sockets ==

<pre>
sock socket "tcp4" "9050" "0.0.0.0"
sock_send(socket, "ping")
sock_listen(socket, {"ping": "pong"})
</pre>

<code>sock_listen</code> dispatches messages from a hash and <code>sock_send</code> sends a message through an open socket.

== HTTP ==

<code>webserver(port, routes)</code> starts an HTTP server. See [[O_Language/Web|Web Programming]] for route and request examples.

== Database ==

The database API includes <code>database</code>, <code>model</code>, <code>migrate</code>, <code>fetch</code>, <code>create</code>, <code>update</code>, <code>delete</code>, <code>drop</code>, <code>truncate</code>, <code>query</code>, and <code>search</code>. See [[O_Language/Web/Database|Database]] for a complete example.

[[Category:O Language]]
[[Category:O Language API]]

O Language/API/CLI

2026-08-25T07:32:47Z

Tedaryum: Protected "O Language/API/CLI" ([Edit=Allow only administrators] (indefinite) [Move=Allow only administrators] (indefinite))

= CLI =

The <code>olang</code> executable runs source files, starts the REPL, manages packages and processes, and operates web projects.

== Source commands ==

<pre>
olang # Start the REPL
olang run <file> # Run a source file
olang exec 'output("Hello")'
olang compile -f <file> -o <output>
</pre>

== Package commands ==

<pre>
olang install [-f library.olp]
olang info [-f library.olp]
olang generate [-f library.olp]
olang create --name <project> --repo <remote>
olang get <name> <remote>
olang job <name>
</pre>

<code>library.olp</code> stores package metadata and dependency definitions.

== Process commands ==

<pre>
olang process --start true --file proc.ops
olang process --stop true --file proc.ops
olang process --init true --file proc.ops
</pre>

== Web commands ==

<pre>
olang web init <local>
olang web init <remote> <local>
olang web run
olang web stop
olang web create controller [name]
olang web create model [name]
olang web create connection [name]
olang web create route <method> <path> <controller>
olang web add <remote> <library-name>
olang web install
olang web update
olang web artifact <filename>
</pre>

The web CLI writes generated routes to <code>config/config.ola</code> and keeps <code>lib/loader.olm</code> current. See [[O_Language/Web_Framework|O Language Web Framework]] for the workflow.

[[Category:O Language]]
[[Category:O Language API]]

O Language/API/Functions

2026-08-25T07:32:42Z

Tedaryum: Protected "O Language/API/Functions" ([Edit=Allow only administrators] (indefinite) [Move=Allow only administrators] (indefinite))

= Built-in Functions =

This page summarizes the current built-in registry in the O Language source repository.

== Values and collections ==

<code>itostr</code>, <code>atostr</code>, <code>getval</code>, <code>type</code>, <code>len</code>, <code>first</code>, <code>last</code>, <code>rest</code>, <code>push</code>, <code>map</code>, <code>replace</code>, and <code>rand</code> operate on values and collections.

== Console, files, and data ==

Console functions include <code>output</code>, <code>input</code>, and <code>inspect</code>. File functions include <code>read</code>, <code>write</code>, <code>remove</code>, <code>mkdir</code>, <code>rmdir</code>, <code>finfo</code>, <code>chmod</code>, <code>exist</code>, <code>wdir</code>, and <code>chdir</code>. Data helpers include <code>json</code>, <code>jsonp</code>, <code>jsonf</code>, <code>xmlp</code>, <code>xmlf</code>, and <code>renderf</code>.

== Processes and networking ==

Process functions include <code>open</code>, <code>run</code>, <code>exec</code>, <code>sh_exec</code>, <code>cmd_exec</code>, <code>proc_out</code>, <code>proc_pid</code>, <code>proc_kill</code>, and <code>sysenv</code>. Networking functions include <code>webserver</code>, <code>sock_send</code>, and <code>sock_listen</code>.

== Database ==

<code>database</code>, <code>model</code>, <code>migrate</code>, <code>fetch</code>, <code>create</code>, <code>update</code>, <code>delete</code>, <code>drop</code>, <code>truncate</code>, <code>query</code>, and <code>search</code> provide database operations. See [[O_Language/Web/Database|Database]] for examples.

== Other runtime functions ==

Other registered helpers include <code>args</code>, <code>colorize</code>, <code>regexp_check</code>, <code>regexp_find</code>, <code>math_sum</code>, <code>math_abs</code>, <code>math_cos</code>, <code>math_sin</code>, <code>math_tan</code>, <code>math_log</code>, <code>encrypt</code>, <code>decrypt</code>, <code>hash_encode</code>, <code>hash_decode</code>, <code>fwatch</code>, <code>asm</code>, <code>quit</code>, and <code>exit</code>.

[[Category:O Language]]
[[Category:O Language API]]

O Language/API/Types

2026-08-25T07:32:33Z

Tedaryum: Protected "O Language/API/Types" ([Edit=Allow only administrators] (indefinite) [Move=Allow only administrators] (indefinite))

= Types =

O Language values are dynamically represented at runtime.

{| class="wikitable"
! Value !! Example !! Description
|-
| Integer || <code>42</code> || Signed whole number.
|-
| Float || <code>3.14</code> || Floating-point number.
|-
| Boolean || <code>true</code> || Boolean value.
|-
| String || <code>"O Language"</code> || Text value.
|-
| Array || <code>[1, "two", true]</code> || Ordered, zero-based collection.
|-
| Hash || <code>{"name": "O"}</code> || Key/value collection.
|-
| Function || <code>fn(x) { return x + 1 }</code> || Callable value.
|-
| Empty || Missing or void result || Context-dependent empty result.
|}

The runtime also exposes system values for processes, environments, sockets, database connections, models, routes, requests, signals, modules, closures, compiled functions, and errors.

== Indexing ==

<pre>
def items = ["first", "second"]
output(items[0])

def user = {"name": "Ada"}
output(user["name"])
</pre>

Use <code>type</code> to inspect a runtime type. Use <code>itostr</code>, <code>atostr</code>, and <code>getval</code> for common conversions.

[[Category:O Language]]
[[Category:O Language API]]

O Language/API/Tokens

2026-08-25T07:32:26Z

Tedaryum: Protected "O Language/API/Tokens" ([Edit=Allow only administrators] (indefinite) [Move=Allow only administrators] (indefinite))

= Tokens and Operators =

== Literals ==

{| class="wikitable"
! Token !! Example
|-
| Identifier || <code>name</code>
|-
| Integer || <code>42</code>
|-
| Float || <code>3.14</code>
|-
| String || <code>"hello"</code>
|-
| Boolean || <code>true</code>, <code>false</code>
|}

Comments start with <code>#</code> and continue to the end of the source input.

== Operators and delimiters ==

Arithmetic operators are <code>+</code>, <code>-</code>, <code>*</code>, and <code>/</code>. Comparisons use <code>==</code>, <code>!=</code>, <code><</code>, <code>></code>, <code><=</code>, and <code>>=</code>. Boolean negation uses <code>!</code>. Scope member access uses <code>-></code>.

Parentheses group expressions and function arguments. Braces delimit blocks and hashes. Brackets delimit arrays and indexes. Commas separate items, colons separate hash keys and values, and semicolons separate statements.

== Keywords ==

<code>fn</code>, <code>def</code>, <code>true</code>, <code>false</code>, <code>if</code>, <code>else</code>, <code>return</code>, <code>print</code>, <code>load</code>, <code>loop</code>, <code>scope</code>, <code>proc</code>, <code>env</code>, <code>sock</code>, <code>for</code>, <code>in</code>, <code>self</code>, <code>literal</code>, <code>begin</code>, <code>except</code>, <code>recover</code>, <code>final</code>, <code>float</code>, <code>route</code>, <code>set</code>, <code>impl</code>, <code>signal</code>, <code>eval</code>, <code>async</code>, <code>wait</code>, and <code>while</code>.

[[Category:O Language]]
[[Category:O Language API]]

O Language/API/Syntax

2026-08-25T07:32:21Z

Tedaryum: Protected "O Language/API/Syntax" ([Edit=Allow only administrators] (indefinite) [Move=Allow only administrators] (indefinite))

= Syntax =

== Definitions and expressions ==

<pre>
def answer = 6 * 7
def greeting = "Hello, " + "world!"
output(answer)
</pre>

Statements may be separated with semicolons. Braces delimit blocks, hashes, and scopes.

== Functions ==

<pre>
def add = fn(left, right) {
return left + right
}

output(add(2, 3))
</pre>

Functions are first-class values and can be passed to <code>map</code>.

== Conditions and iteration ==

Use <code>if</code> and <code>else</code> for branches. Use <code>while</code> and <code>loop</code> for condition-based repetition. Use <code>for</code> with <code>in</code> to iterate arrays and hashes.

== Scopes and modules ==

<pre>
scope math {
def double = fn(x) { return x * 2 }
}

output(math->double(4))
load "helpers.olm"
</pre>

Other parser forms include <code>proc</code>, <code>env</code>, <code>sock</code>, <code>route</code>, <code>signal</code>, <code>eval</code>, <code>async</code>, <code>wait</code>, <code>set</code>, <code>literal</code>, and <code>impl</code>.

[[Category:O Language]]
[[Category:O Language API]]

O Language/API

2026-08-25T07:32:14Z

Tedaryum: Protected "O Language/API" ([Edit=Allow only administrators] (indefinite) [Move=Allow only administrators] (indefinite))

= API Reference =

This is the complete reference section. Use it when you know what you want to do and need the exact name, form, or accepted value.

* [[O_Language/API/Syntax|Syntax]] — definitions, functions, control flow, scopes, and language forms.
* [[O_Language/API/Tokens|Tokens and Operators]] — literals, operators, delimiters, and keywords.
* [[O_Language/API/Types|Types]] — language values and runtime objects.
* [[O_Language/API/Functions|Built-in Functions]] — the built-in runtime function registry.
* [[O_Language/API/CLI|CLI]] — <code>olang</code> commands, process management, and web commands.
* [[O_Language/API/System|System APIs]] — files, processes, environment, sockets, HTTP, and database operations.

Web concepts and framework workflows remain in [[O_Language/Web|Web Programming]] and [[O_Language/Web_Framework|O Language Web Framework]] so that this reference stays focused on exact API behavior.

[[Category:O Language]]
[[Category:O Language API]]

O Language/Web Framework

2026-08-25T07:32:01Z

Tedaryum: Protected "O Language/Web Framework" ([Edit=Allow only administrators] (indefinite) [Move=Allow only administrators] (indefinite)) [cascading]

= O Language Web Framework (olf) =

<code>olf</code> is the convention-based web framework for O Language. It provides a project layout for routes, controllers, templates, browser assets, and database code.

== Create and run a project ==

<pre>
olang web init my-project
cd my-project
olang web run
</pre>

The official framework source is [https://gitlab.com/olanguage/web/framework the olf repository].

== Project structure ==

{| class="wikitable"
! Path !! Responsibility
|-
| <code>boot.ola</code> || Starts the application by loading <code>lib/loader.olm</code>.
|-
| <code>lib/loader.olm</code> || Central loader for every generated and installed module.
|-
| <code>config/config.ola</code> || HTTP route table.
|-
| <code>controllers/</code> || Request handler functions.
|-
| <code>models/</code> || Data model definitions.
|-
| <code>connections/</code> || Database connection definitions.
|-
| <code>templates/</code> || Server-rendered HTML templates.
|-
| <code>public/</code> || Browser assets.
|-
| <code>library.olp</code> || Project metadata and dependencies.
|-
| <code>proc.ops</code> || Local process definition.
|}

== Generate application components ==

<pre>
olang web create controller home
olang web create model user
olang web create connection main
olang web create route get /users/:id show_user
</pre>

The web CLI updates <code>lib/loader.olm</code> whenever it creates or installs a component. Controller and route definitions are written to <code>config/config.ola</code>; no separate route file is created. Generated controller functions are intentionally empty so the developer can fill in the behavior.

== Add libraries ==

<pre>
olang web add <remote> <library-name>
olang web install
olang web update
</pre>

The dependency is recorded in <code>library.olp</code>, installed under <code>lib/</code>, and its entry point is added to the central loader.

== Templates and request data ==

<pre>
def main = fn() {
return renderf("templates/index.html", {
"title": "My Olang App",
"body": "Welcome!"
})
}
</pre>

Use <code>server.parameters</code> for route parameters and <code>server.get</code>, <code>server.post</code>, <code>server.headers</code>, and <code>server.form</code> for request data.

[[Category:O Language]]
[[Category:O Language Web Framework]]

O Language/Advanced/Runtime

2026-08-25T07:31:26Z

Tedaryum: Protected "O Language/Advanced/Runtime" ([Edit=Allow only administrators] (indefinite) [Move=Allow only administrators] (indefinite))

= Modules and Loading =

Modules use the <code>.olm</code> extension. A module can define functions and values that become available to the program that loads it.

<pre>
load "helpers.olm"
</pre>

The path is resolved from the current project directory. Keep shared definitions in modules instead of repeating them in every entry point.

== Web project loading ==

Web projects use one central loader:

<pre>
load "lib/loader.olm"
</pre>

<code>boot.ola</code> loads <code>lib/loader.olm</code>. The loader loads controllers, models, connections, libraries, and finally <code>config/config.ola</code>. Controllers must be loaded before the route configuration because route responses refer to handler functions.

When the web CLI creates or adds a project component, it updates the loader automatically. This keeps the boot process in one place.

[[Category:O Language]]
[[Category:O Language Advanced]]

O Language/Advanced/Modules

2026-08-25T07:31:20Z

Tedaryum: Protected "O Language/Advanced/Modules" ([Edit=Allow only administrators] (indefinite) [Move=Allow only administrators] (indefinite))

O Language/Advanced

2026-08-25T07:31:14Z

Tedaryum: Protected "O Language/Advanced" ([Edit=Allow only administrators] (indefinite) [Move=Allow only administrators] (indefinite))

= Advanced Topics =

Use this section after [[O_Language/Getting_Started|Getting Started]]. It covers the runtime model and language features used in larger programs.

== Modules ==

Move reusable definitions into <code>.olm</code> modules and load them by path. The complete loading order and project loader conventions are described in [[O_Language/Advanced/Modules|Modules and Loading]].

== Runtime control ==

O Language can start external processes, work with environment values, and coordinate asynchronous work. The reference details are in [[O_Language/Advanced/Runtime|Runtime and Concurrency]].

== Sockets ==

Message-oriented socket communication is available through the <code>sock</code>, <code>sock_listen</code>, and <code>sock_send</code> APIs. Use it when an HTTP request/response model is not appropriate.

<pre>
sock socket "tcp4" "9050" "0.0.0.0"
def messages = {"ping": "pong"}
sock_listen(socket, messages)
</pre>

See [[O_Language/API/System|System APIs]] for the full socket and process reference.

[[Category:O Language]]
[[Category:O Language Advanced]]

O Language/Getting Started/Project Files

2026-08-25T07:30:49Z

Tedaryum: Protected "O Language/Getting Started/Project Files" ([Edit=Allow only administrators] (indefinite) [Move=Allow only administrators] (indefinite))

= Project Files =

O Language projects use a small number of file types:

{| class="wikitable"
! Extension !! Use
|-
| <code>.ola</code> || Application source or an entry-point file.
|-
| <code>.olm</code> || Loadable O Language module.
|-
| <code>.olp</code> || Package metadata and dependency definitions.
|-
| <code>.ops</code> || Process configuration.
|-
| <code>.obc</code> || Compiled bytecode output.
|}

Web projects also use conventional directories such as <code>controllers/</code>, <code>models/</code>, <code>connections/</code>, <code>config/</code>, and <code>lib/</code>. See [[O_Language/Web_Framework|O Language Web Framework]] for their roles.

[[Category:O Language]]
[[Category:O Language Getting Started]]

O Language/Getting Started/Language Basics

2026-08-25T07:30:43Z

Tedaryum: Protected "O Language/Getting Started/Language Basics" ([Edit=Allow only administrators] (indefinite) [Move=Allow only administrators] (indefinite))

= Language Basics =

== Values and definitions ==

Use <code>def</code> to bind a value to a name. O Language supports numbers, text, booleans, arrays, hashes, and functions.

<pre>
def answer = 6 * 7
def greeting = "Hello, world!"
def enabled = true
def colors = ["red", "blue"]
def user = {"name": "Ada"}

output(answer)
</pre>

== Functions ==

Functions are values. Define one with <code>fn</code>, return a value with <code>return</code>, and call it by name.

<pre>
def add = fn(left, right) {
return left + right
}

output(add(2, 3))
</pre>

== Conditions and loops ==

<pre>
if (answer >= 42) {
output("ready")
} else {
output("not ready")
}

for (colors in index, value) {
output(value)
}
</pre>

Use <code>while</code> or <code>loop</code> for condition-based repetition. Use <code>map</code> when a function should be applied to the items in a collection.

== Read more ==

The complete grammar and value model are in [[O_Language/API/Syntax|Syntax]], [[O_Language/API/Tokens|Tokens and Operators]], and [[O_Language/API/Types|Types]].

[[Category:O Language]]
[[Category:O Language Getting Started]]

O Language/Getting Started

2026-08-25T07:30:37Z

Tedaryum: Protected "O Language/Getting Started" ([Edit=Allow only administrators] (indefinite) [Move=Allow only administrators] (indefinite))

= Getting Started =

This section is for a new O Language user. It explains the language's purpose, the first program, and the small set of ideas needed before reading the advanced or reference pages.

== What is O Language? ==

O Language is a system-oriented functional language. Values and functions are central, while system operations such as processes, files, networking, and databases are available from the same runtime.

The official source repository is [https://gitlab.com/olanguage/olang.git gitlab.com/olanguage/olang]. This documentation assumes that the <code>olang</code> executable is already available on <code>PATH</code>.

== Your first program ==

Create <code>hello.ola</code>:

<pre>
output("Hello, World!")
</pre>

Run it:

<pre>
olang hello.ola
</pre>

Run <code>olang</code> without a file to open the interactive REPL.

== Learn the core ideas ==

* [[O_Language/Getting_Started/Language_Basics|Language Basics]] introduces values, definitions, functions, conditions, loops, and collections.
* [[O_Language/Getting_Started/Project_Files|Project Files]] explains <code>.ola</code>, <code>.olm</code>, <code>.olp</code>, and <code>.ops</code> files.
* [[O_Language/Web|Web Programming]] shows how the same language concepts are used in an HTTP application.

When these ideas are familiar, continue to [[O_Language/Advanced|Advanced Topics]] or use the [[O_Language/API|API Reference]].

[[Category:O Language]]
[[Category:O Language Getting Started]]

OnixOS:Copyrights

2026-08-25T07:29:59Z

Tedaryum: Protected "OnixOS:Copyrights" ([Edit=Allow only administrators] (indefinite) [Move=Allow only administrators] (indefinite))

= OnixOS:Copyrights =

This page describes the copyright and licensing information for software documented by the OnixOS project.

== O Language and olf ==

The O Language runtime and the <code>olf</code> web framework are released under the MIT License.

{| class="wikitable"
! Project !! Copyright holder !! License !! Source
|-
| [https://gitlab.com/olanguage/olang O Language]
| Oytun Özdemir, 2017
| [https://opensource.org/license/mit MIT License]
| [https://gitlab.com/olanguage/olang/-/blob/master/LICENSE LICENSE]
|-
| [https://gitlab.com/olanguage/web/framework olf Web Framework]
| Oytun Özdemir, 2017
| [https://opensource.org/license/mit MIT License]
| [https://gitlab.com/olanguage/web/framework/-/blob/master/LICENSE LICENSE]
|}

The MIT License permits use, copying, modification, publication, distribution, sublicensing, and sale of the software, provided that the copyright notice and permission notice are included in copies or substantial portions of the software.

== O Language VS Code extension ==

The O Language VS Code extension is a separate project and is distributed under the GNU General Public License, version 3.

* Project: [https://gitlab.com/olanguage/editors/olanguage-vscode O Language VS Code extension]
* License: [https://www.gnu.org/licenses/gpl-3.0.html GNU General Public License v3.0]
* License file: [https://gitlab.com/olanguage/editors/olanguage-vscode/-/blob/master/LICENSE.md LICENSE.md]

== Third-party software ==

Third-party libraries and tools retain their own copyright and license terms. Their licenses are not replaced by the license of O Language, <code>olf</code>, or any OnixOS documentation.

When redistributing a project, review the license files included by that project and its dependencies. Preserve required copyright notices and license texts.

== Documentation ==

The O Language documentation in this wiki is maintained as part of the [https://gitlab.com/olanguage/docs O Language documentation repository]. Documentation pages and included assets may have separate terms; check the relevant source repository or page notice before redistribution.

For the legally binding terms, always consult the license file in the relevant source repository.

[[Category:OnixOS]]
[[Category:Copyrights]]

OnixOS talk:Copyrights

2026-08-25T07:29:52Z

Tedaryum: Created blank page

OnixOS:Copyrights

2026-08-25T07:29:45Z

Tedaryum: Created page with "= OnixOS:Copyrights = This page describes the copyright and licensing information for software documented by the OnixOS project. == O Language and olf == The O Language runtime and the <code>olf</code> web framework are released under the MIT License. {| class="wikitable" ! Project !! Copyright holder !! License !! Source |- | [https://gitlab.com/olanguage/olang O Language] | Oytun Özdemir, 2017 | [https://opensource.org/license/mit MIT License] | [https://gitlab.co..."

Forum

2026-08-25T07:29:36Z

Tedaryum: Protected "Forum" ([Edit=Allow only administrators] (indefinite) [Move=Allow only administrators] (indefinite))

The official community forum for the Onix Project, where users can engage in discussions, share feedback, and access support resources, can be found at https://forum.onix-project.com/.

Telegram channel: http://t.me/onixos_community

Planet

2026-08-25T07:29:26Z

Tedaryum: Protected "Planet" ([Edit=Allow only administrators] (indefinite) [Move=Allow only administrators] (indefinite))

OnixOS Planet is an aggregator page that collects blog posts and updates from the OnixOS community, providing a centralized stream of developer content.

https://planet.onix-project.com/

Talk:Forum

2026-08-25T07:29:18Z

Tedaryum: Created blank page

Download

2026-08-25T07:29:07Z

Tedaryum: Protected "Download" ([Edit=Allow only administrators] (indefinite) [Move=Allow only administrators] (indefinite))

OnixOS is a public and open source operating system. It is an operating system with “O Language” support for developers and users. You have many options to download the latest version.

<htmltag tagname="a" href="https://sourceforge.net/projects/onixos/files/latest/download"><htmltag tagname="img" alt="Download OnixOS" src="https://a.fsdn.com/con/app/sf-download-button" width="276" height="48" srcset="https://a.fsdn.com/con/app/sf-download-button?button_size=2x 2x" /></htmltag>

=== ISO (x86_64) ===

We will give you a few ISO links for Daily and Stable Updates. You can download anything you want from these links.

* [https://sourceforge.net/projects/onixos/files/Release/ Stable Updates (Source Forge Mirror)]
* [https://sourceforge.net/projects/onixos/files/Daily/ Daily Updates (Source Forge Mirror)]
* [http://pub.onix-project.com/ Daily Updates (Onix Project Mirror)]

=== Docker ===

You can use the following links to develop a project on OnixOS on Docker or to work on a Docker version.

docker pull olproject/onixos
docker run -it olproject/onixos /bin/bash

docker pull olproject/olang
docker run -t olproject/olang olang <olang file>

You can start working on docker using the command above.

=== Vagrant ===

To use the OnixOS operating system on Vagrant and make improvements, you can use the following commands or links.

To use it in a new project;

vagrant init olproject/onixos --box-version 3.0

To use it in the Vagrantfile file;

Vagrant.configure("2") do |config|
config.vm.box = "olproject/onixos"
config.vm.box_version = "3.0"
config.ssh.username = "vagrant"
config.ssh.password = "vagrant"
config.ssh.insert_key = true
end

=== Arch Linux Mirrors ===

You can install packages in repositories on your own Arch Linux-based system using Arch Linux repositories.

The pacman we mentioned at the bottom.you can use the conf and mirrorlist files under /etc/.

* [https://gitlab.com/onix-os/onix-build-system/-/blob/main/sources/profiles/core/pacman.conf pacman.conf]
* [https://gitlab.com/onix-os/onix-build-system/-/blob/main/sources/profiles/core/airootfs/etc/pacman.d/mirrorlist mirrorlist]

[onix-base]
SigLevel = Never
Server = http://repo.onix-project.com/base/
[onix-aur]
SigLevel = Never
Server = http://repo.onix-project.com/aur/

O Language

2026-08-25T07:28:55Z

Tedaryum: Protected "O Language" ([Edit=Allow only administrators] (indefinite) [Move=Allow only administrators] (indefinite))

= O Language =

'''O Language''' is a '''System-Oriented Functional Programming Language (SOFPL)'''. It combines functional values with direct access to processes, files, sockets, databases, and HTTP services.

The official source repository is [https://gitlab.com/olanguage/olang.git gitlab.com/olanguage/olang].

== Index ==

Start with the first section and use the later sections as your needs grow.

* '''Getting Started''' — learn what O Language is, write a first program, and understand the basic project model.
** [[O_Language/Getting_Started|Getting Started]]
** [[O_Language/Getting_Started/Language_Basics|Language Basics]]
** [[O_Language/Getting_Started/Project_Files|Project Files]]
* '''Advanced''' — continue here after learning the core language.
** [[O_Language/Advanced|Advanced Topics]]
** [[O_Language/Advanced/Modules|Modules and Loading]]
** [[O_Language/Advanced/Runtime|Runtime and Concurrency]]
* '''Web''' — build HTTP applications with the language runtime.
** [[O_Language/Web|Web Programming]]
** [[O_Language/Web/Routing|Routing]]
** [[O_Language/Web/Database|Database]]
* '''O Language Web Framework''' — create and operate projects with the <code>olf</code> conventions and web CLI.
** [[O_Language/Web_Framework|O Language Web Framework]]
* '''API''' — complete reference for the language, runtime, and command-line tools.
** [[O_Language/API|API Reference]]
** [[O_Language/API/Syntax|Syntax]]
** [[O_Language/API/Tokens|Tokens and Operators]]
** [[O_Language/API/Types|Types]]
** [[O_Language/API/Functions|Built-in Functions]]
** [[O_Language/API/CLI|CLI]]
** [[O_Language/API/System|System APIs]]
* '''Free Books'''
**[[:File:OlangForNewbies-TR.pdf|Turkish]]
**[[:File:OlangForNewbies-EN.pdf|English]]

[[Category:O Language]]
[[Category:Programming languages]]

Talk:O Language/API/System

2026-08-25T07:28:23Z

Tedaryum: Created blank page

Talk:O Language/API/CLI

2026-08-25T07:28:18Z

Tedaryum: Created blank page

Talk:O Language/API/Functions

2026-08-25T07:28:10Z

Tedaryum: Created blank page

Talk:O Language/API/Types

2026-08-25T07:27:59Z

Tedaryum: Created blank page

Talk:O Language/API/Tokens

2026-08-25T07:27:44Z

Tedaryum: Created blank page

Talk:O Language/API/Syntax

2026-08-25T07:27:26Z

Tedaryum: Created blank page

Talk:O Language/API

2026-08-25T07:27:20Z

Tedaryum: Created blank page

Talk:O Language/Web/Database

2026-08-25T07:26:57Z

Tedaryum: Created blank page

Talk:O Language/Web/Routing

2026-08-25T07:26:50Z

Tedaryum: Created blank page

Talk:O Language/Web

2026-08-25T07:26:44Z

Tedaryum: Created blank page

Talk:O Language/Advanced/Modules

2026-08-25T07:26:34Z

Tedaryum: Created blank page

Talk:O Language/Advanced

2026-08-25T07:26:28Z

Tedaryum: Created blank page

Talk:O Language/Getting Started/Project Files

2026-08-25T07:26:21Z

Tedaryum: Created blank page

Talk:O Language/Getting Started/Language Basics

2026-08-25T07:26:16Z

Tedaryum: Created blank page

Talk:O Language/Getting Started

2026-08-25T07:26:09Z

Tedaryum: Created blank page

Talk:O Language/Web Framework

2026-08-25T07:25:21Z

Tedaryum: Created blank page

O Language/API/System

2026-08-25T07:22:19Z

Tedaryum: Created page with "= System APIs = System APIs connect O Language programs to the operating system and external services. == Files and environment == Use <code>read</code>, <code>write</code>, <code>remove</code>, <code>mkdir</code>, <code>rmdir</code>, <code>finfo</code>, <code>chmod</code>, <code>exist</code>, <code>wdir</code>, and <code>chdir</code> for files and directories. Use <code>sysenv</code> to read environment values. == Processes == Use <code>open</code>, <code>run</code..."

O Language/API/CLI

2026-08-25T07:21:45Z

Tedaryum: Created page with "= CLI = The <code>olang</code> executable runs source files, starts the REPL, manages packages and processes, and operates web projects. == Source commands == <pre> olang # Start the REPL olang run <file> # Run a source file olang exec 'output("Hello")' olang compile -f <file> -o <output> </pre> == Package commands == <pre> olang install [-f library.olp] olang info [-f library.olp] olang generate [-f library.olp..."

O Language/API/Functions

2026-08-25T07:21:30Z

Tedaryum: Created page with "= Built-in Functions = This page summarizes the current built-in registry in the O Language source repository. == Values and collections == <code>itostr</code>, <code>atostr</code>, <code>getval</code>, <code>type</code>, <code>len</code>, <code>first</code>, <code>last</code>, <code>rest</code>, <code>push</code>, <code>map</code>, <code>replace</code>, and <code>rand</code> operate on values and collections. == Console, files, and data == Console functions include..."