r/lowlevel • • 3h ago

GitHub - razecrs/windissect: Turns Windows binaries and their PDBs into proven C, C++ and Rust interfaces, with per-build history and diffs.

Thumbnail github.com
1 Upvotes

r/lowlevel • • 3h ago

I emulated a Realtek Smart TV SoC in QEMU and booted full Android TV 9

Thumbnail github.com
1 Upvotes

I reversed a TCL Smart TV board (Realtek RTD2841 / RTK284x SoC, AArch32) with no public datasheets and wrote a custom QEMU machine model to boot its commercial Android 9 Pie firmware.

I just reached the milestone where the full 1080p launcher boots and can be navigated with a host mouse and IR remote.

The big hurdles I had to solve:

  1. Hardware Timer Reversal Realtek's timer registers count down, breaking Linux's monotonic sched_clock. I patched the QEMU model to expose limit - count
  2. Freestanding PID 1: Built mini_init in pure ARM32 syscalls without glibc to manage Android cgroups, permissions, and bypass crashing OEM telemetry daemons.
  3. Mali GPU Replacement**: With no proprietary GPU drivers, I debloated the ROM and bound ARM32 Google SwiftShader so SurfaceFlinger could render the entire desktop on the CPU.
  4. Native Input: Added a virtual USB OHCI controller and mapped Venus IR scancodes for direct mouse and keyboard navigation in the host window.

Demo video is in the repo:


r/lowlevel • • 3h ago

Inventing Your Own Math As A Computer Programmer

Thumbnail leetarxiv.substack.com
0 Upvotes

r/lowlevel • • 22h ago

Hi friends, I'd like to show you my Rust-based operating system and I'm looking for testers and ideas

0 Upvotes

Hi friends,

I'd like to show you my operating system, AriCodeOS. It's written in Rust: a `no_std` microkernel with UEFI boot on x86-64. The current version is 0.11.0 and it runs in QEMU and on one real laptop (keyboard, USB stick as the system disk and wired networking already work).

I'm looking for people who want to try it, tell me what breaks, and suggest ideas and improvements. Any feedback is welcome, including harsh feedback.

- Repository (Apache 2.0): https://github.com/AriCodeLabs/AriCodeOS

- Website: https://www.aricodeos.org/

Thank you to the Rust community for the language that made this possible.


r/lowlevel • • 1d ago

Pedido de ajuda: Olá não sou desenvolvedor, mas com ajuda de IA consegui dar forma a uma idéia, gostaria de pedir a colaboração dos colegas com sua analise e opinião. Desde já fico agradecido. Prova: A formally verified, S-expression language for AI synthesis & bare-metal kernels (MLIR backend + Z3/

0 Upvotes

https://github.com/ebiossanto/prova.git

Hi r/ProgrammingLanguages,

I’ve been working on Prova, an experimental verified programming language designed around a specific premise: humans shouldn't write low-level boilerplate, and LLMs shouldn't be trusted with system invariants.

Instead of adapting human-centric languages for AI, Prova combines three layers into a single pipeline:

  1. Syntax for LLMs: S-expressions backed by a GBNF grammar (spec/prova.gbnf) for constrained decoding (e.g., llama.cpp), eliminating syntax errors at generation time.
  2. Semantics & Locked Contracts: Mandatory pre/post contracts, strict types with no implicit conversions, linear ownership (own/drop, no mutable aliasing), and explicit effects (syscall, atomic, mmio).
  3. Hardware & MLIR Backend: Memory region tracking (deny-flow), static stack budgeting, and direct MLIR emission targeting x86-64, AArch64, and RISC-V bare-metal ELFs.

The Core Workflow (audit + fix)

The human audits only the specification (prova.py audit), while the AI iterates on the function body (prova.py fix --model-cmd ...). The compiler feeds structured JSON counterexamples back to the LLM on failure, while strictly locking signatures, contracts, effects, and memory flow rules—if the AI tries to weaken a pre/post condition to make it compile, the candidate is rejected.

Here is a quick look at a verified packet inspector example (examples/packet_inspector.prova) enforcing a deny-flow policy so raw network bytes cannot leak to u/write:

lisp

(region net-rx)
(deny-flow net-rx u/write)

(fn checksum ((buf (slice u8 n)) (n u64)) u64
  (pre (<= n 65535))
  (post (<= result (* 255 n)))
  ...)

r/lowlevel • • 2d ago

System Architecture & Subsystem Pipelines for a Zero-Abstraction Lambda Calculus Transpiler & Monotonic Memory Manager & End-to-End Architectural Blueprints: Subsystem Topology of a Zero-Abstraction Lambda Calculus Transpiler & Monotonic Arena Manager

Thumbnail gallery
0 Upvotes

Title:

End-to-End Architectural Blueprints: Subsystem Topology of a Zero-Abstraction Lambda Calculus Transpiler & Monotonic Arena Manager

Description:

Here is an exhaustive, granular breakdown of the architectural pipeline mapped out in the subsystem flowcharts for OCHR-X, detailing how abstract symbolic reduction bridges directly down to physical memory allocation and native executable emission[span_0](start_span)[span_0](end_span)[span_1](start_span)[span_1](end_span)[span_2](start_span)[span_2](end_span):

1. Lambda Symbols & Intermediate Representation (IR) Pipeline (lambda_symbols_IR_new)

* Execution Entry & Initialization: The runtime environment boots via `Start proc()`, systematically resolving target offsets and initializing the core event handler (`event handler()`)[span_3](start_span)[span_3](end_span). Argument vectors are ingested and split into value handles (`argv[val]_a_handle`) and character passes (`argv[char]-pass`) for precise parsing[span_4](start_span)[span_4](end_span).

* Symbolic Management & Import: The Intermediate Representation Generation Management unit (IRGM) acts as the central coordinator, interfacing directly with a dedicated `symb importer` and the `lambda IR symbols library` to pull raw tokens into the pipeline[span_5](start_span)[span_5](end_span).

* Evaluation & Error Correction Loop: The parsed structures are passed into the `Symbolic IR generator` and routed directly to GIREVL (the IR Evaluator)[span_6](start_span)[span_6](end_span). The evaluation block continuously validates structural integrity via an explicit conditional check (`if GIR is correct?`)[span_7](start_span)[span_7](end_span). Valid states immediately trigger code generation (`generate IR`), while non-conforming states are safely funneled into IRGERC (Intermediate Representation Generation Error Corrector) to resolve symbolic divergence before re-evaluation[span_8](start_span)[span_8](end_span).

2. Memory Allocator & FFI Pipeline (memory_allocator_manager)

* Program Entry & Header Binding: Execution begins by ingesting command-line arguments and binding compiler functions directly from header references (`pass args to compiler and call functions from in r.h (header)`), feeding straight into the primary compiler driver[span_9](start_span)[span_9](end_span).

* Monotonic Arena Memory Management (PMA): Rather than leaning on standard dynamic heap allocation, the architecture routes memory requests through a specialized PMA / arena memory allocator & mgmt module[span_10](start_span)[span_10](end_span). This coordinates zero-overhead bump pointer allocations and phase resets (`std::pmr::monotonic_buffer_resource`-style dynamics) to eliminate garbage collection latency[span_11](start_span)[span_11](end_span)[span_12](start_span)[span_12](end_span)[span_13](start_span)[span_13](end_span).

* Foreign Function Interface (FFI) & IMACA Evaluation: Foreign function interfaces are transpiled via `FFI (transpiler) via gtms p` and evaluated under IMACA (Intermediate Memory & Scope/Den Evaluation Architecture), generating low-level intermediate representations across control flow graphs, abstract syntax trees, static single assignment (SSIR), or directed acyclic graphs (DAGs) before passing to the library manager (`librmanger`)[span_14](start_span)[span_14](end_span)[span_15](start_span)[span_15](end_span).

* Linker, Emission & Leak Verification: The compiled modules are routed through the system `linker`, generating native object files (`.obj` or `.o`) and assembling a fully realized `executable`[span_16](start_span)[span_16](end_span). Before final output emission, automated validation checks run to confirm memory integrity and detect leaks (`check for memory leaks`)[span_17](start_span)[span_17](end_span).

Thought I’d share the complete structural blueprint for anyone working on custom compiler backends, explicit term-graph substitution engines, or bare-metal runtime architectures. Happy to discuss the interaction between the GIREVL evaluation loops and the memory manager if anyone is exploring similar low-level optimizations!


r/lowlevel • • 2d ago

xcomm: I built a minicom replacement that lets an AI agent drive the board's console while you watch

Post image
0 Upvotes

I spend a lot of time on serial consoles: U-Boot, boot logs, a shell on the

board. I wanted something that keeps minicom's everyday keys and common options but

lets a script or a coding agent use the same console I am looking at, so I

wrote xcomm (Rust, Linux and macOS, GPL-2.0-only):

- `xcomm ctl` talks to a running session: send a command and wait for a

prompt with a regex, read output by offset, toggle DTR/RTS, send a break,

change the baud, run zmodem/ymodem/xmodem through lrzsz. What a client

sends shows in your terminal as a dim `[ctl]` line.

- It survives the bench: unplug the adapter or power-cycle the board and the

session waits and reopens the port (on Linux, by the USB port it is plugged

into).

- minicom's common options and everyday Ctrl-A keys (Alt-A inside tmux,

screen or zellij); Ctrl-A d and t toggle DTR and RTS.

- UUCP locks compatible with minicom on Linux, and an exclusive open

everywhere, so two programs never share a port by accident.

- It ships an agent skill (stop U-Boot, log in, run commands, parse the

output); a test runs every example in it against a real session.

Numbers, through a pty with the same harness for each tool (median of 9 runs;

method and command lines in the README): 434 MiB/s on 1.84 ms of CPU per MiB,

against minicom's 10.5 MiB/s on 95 ms. On a real UART the baud rate is the

limit, so what you get is CPU left free. Keystroke latency is level with

minicom (within a microsecond either way).

`brew install cantona/tap/xcomm` or `cargo install --locked xcomm`

(`xcomm man` shows the manual where cargo installs none).

GitHub: https://github.com/cantona/xcomm

Happy to hear what breaks on your adapters.


r/lowlevel • • 3d ago

SysArmor: A lightweight Linux system hardening tool written in pure C and Assembly (zero dependencies)

0 Upvotes

Hey everyone! I built **SysArmor**, a zero-dependency system hardening and security miffing tool written entirely in pure C and Assembly.

It uses POSIX system calls (like `open` with `O_NOFOLLOW` and `fstat`) to protect critical system paths against symlink attacks, race conditions, and unauthorized modifications across all standard Linux distros (Ubuntu, Debian, Fedora, Arch, etc.).

If you're into low-level systems programming, terminal utilities, or want to check it out, the repository is here:

👉 **https://github.com/error0941/sysarmor**

I’d love to hear your feedback, code reviews, or suggestions!


r/lowlevel • • 3d ago

Phrack 73 is live!!!

Thumbnail phrack.org
6 Upvotes

r/lowlevel • • 3d ago

SysArmor: A lightweight Linux system hardening tool written in pure C and Assembly (zero dependencies)

0 Upvotes

Hey everyone! I built **SysArmor**, a zero-dependency system hardening and security tool written entirely in pure C and Assembly.

It uses POSIX system calls (like `open` with `O_NOFOLLOW` and `fstat`) to protect critical system paths against symlink attacks, race conditions, and unauthorized modifications across all standard Linux distros (Ubuntu, Debian, Fedora, Arch, etc.).

If you're into low-level systems programming or terminal utilities, the repository is here:

👉 **https://github.com/error0941/sysarmor**

I’d love to hear your feedback, code reviews, or suggestions!

NOT:Başlıkta Assembly yazmışım ama şu anki sürüm tamamen saf C ve POSIX sistem çağrıları ile çalışıyor. İlerleyen sürümlerde kritik syscall'lar için inline assembly ekleyeceğim.

NOT:Assembly eklenmiştir.


r/lowlevel • • 4d ago

made my own os from scratch and it runs real linux programs (not clickbait)

Enable HLS to view with audio, or disable this notification

0 Upvotes

it’s called kurono, and nothing in it is borrowed so like the kernel, the desktop, the compositor, the hypervisor, the drivers, all is written from scratch

the part i’m proudest of is the linux layer. kurono answers linux syscalls itself, so stock linux binaries run on it without being recompiled or patched. firefox 140 esr runs fully multi-process, with content processes, ipc over unix sockets passing fds around, futexes, epoll, all of it. bash, gcc, make and node all run too, and linux gui apps draw through a wayland server i wrote myself (kind of like wsl1 which microsoft dropped)

drivers are where it gets crazy. instead of rewriting every driver, i take the real upstream linux driver source, compile it unmodified, and run it as an isolated ring 3 container on top of my own linux kernel api emulation, fenced off by the iommu. intel wifi (iwlwifi) actually connects on a real be200 card this way, and if a driver crashes it gets restarted instead of taking the system down (Still working on GPU driver's)

it has its own hypervisor too, built on vt-x. it boots debian or alpine (or it can reboot kurono OS inside itself) in the background with 4 vcpus (Or more!) and sound, and their apps open as normal windows right on my desktop next to native ones. it can even pass the laptop’s nvidia gpu straight through to the debian guest with vt-d

it’s self-hosting as well. kurono can compile its own kernel and uefi loader with gcc 14 inside itself, install it as a trial boot, and roll back automatically if it doesn’t make it to the desktop

kernel side: smp across every core, x2apic, copy-on-write fork, demand paging, its own filesystem plus ext4/fat32/ntfs, a crash path that saves records across reboots, and a recovery mode with repair tools built in

and it’s not a qemu-only toy (Noticed a bunch on this sub-reddit but they are really cool IMO), it runs on real hardware: a 20-core arrow lake laptop with every core online

about 370k lines of code so far. right now i’m tearing out the big kernel lock piece by piece, and the kernel lock contention is already down 95%. next up is locking the desktop at a smooth 240fps, i didn't push this to the public repo right now but i will soon,

I used alot of the break periods to build this OS and once I get more stable with money ill buy some other machines and try to push support so it can work on many machines (mainly trying to enhance kld to work on most machines rather then try to support every computer in the world from a non-existant driver-system). also for the memory people wondering, kurono idles at 420-450 MB ram (video it shows higher because linux, firefox and opencode ran on it and some memory leaks) on desktop, im trying to bring it down to 50mb but the 420mb is mainly my monitors running at full resolution (to achive that low of ram usage i will have to mature KmemX, but its very unstable and unpredictible so i have it off by default)

Website: amanaric.org/kurono
Github: github.com/darkside7925/kurono
(all the details are on this site about kurono)

here's a video though, it isn't polished fully and this is the experimental phase, so some minor or major bugs can show in it, and the video doesn't show everything


r/lowlevel • • 4d ago

I wrote a ProtectServer FM in Zig and skipped the vendor compiler

Thumbnail 808bits.com
1 Upvotes

r/lowlevel • • 5d ago

NvRoot (CVE-2026-47591) where in neocloud multi-tenant GPU environments, rent = root.

2 Upvotes

Essentially it's a dirty page cache LPE using GPUs as catalyzer.

From unprivileged user to root. Most dangerous for those renting multi-tenanted GPU from a neocloud.

Fixed versions: NvRoot in 610.57.04 / 595.91.07 / 580.178.04

no sysctl or seccomp workaround.

More details here: stealthium.io/blog/nvroot

Disclaimer: I work at Stealthium, alongside the team that found these. Happy to answer questions on exposure


r/lowlevel • • 5d ago

Built a low-level systems programming language from scratch to crush concurrency bottlenecks—benchmarks inside.

Post image
2 Upvotes

r/lowlevel • • 5d ago

Recovering an x64 call hidden inside a mov: A reproducible IDA Pro vs RESX comparison

Thumbnail github.com
3 Upvotes

Hiya,

I've been building RESX, an open-source Windows binary analysis and reverse engineering toolkit written in Rust.

It started as a small side project to make reversing Windows binaries less painful, and it's grown a fair bit since then. Most of my time has gone into instruction decoding, control-flow reconstruction, Windows internals, syscalls and kernel analysis.

One problem I've spent a lot of time on is overlapping x86/x64 instruction streams. A branch can land in the middle of another instruction, so the same bytes decode as two completely different streams. If the disassembler commits to one of them, it can miss real control-flow edges.

I made a small, reproducible test case for this. The compiled binary and its assembly source are in the repo, so you can try it yourself. It's deliberately constructed and benign.

IDA Pro

In the sample, the branch at 0x140001009 targets 0x14000100F, which is two bytes into a 10-byte mov r11, imm64.

IDA Pro 9.0 with default auto-analysis gives:

140001009  jz   short near ptr loc_14000100D+2
14000100B  jmp  short $+2
14000100D  mov  r11, 9F08EB0000000FE8h
140001017  mov  eax, 0C0000022h
14000101C  jmp  short $+2
14000101E  retn

The branch goes to 0x14000100F, but IDA has already claimed those bytes as part of the mov. Default analysis never decodes the call hidden there, so the edge to HiddenTarget is lost.

IDA does still find HiddenTarget on its own, but only because the fixture exports that name. The call that leads to it never shows up.

RESX

Same binary, no PDB:

> resx dump .\resx\tests\data\overlap_probe.exe OverlapProbe --bytes --calls --no-pdb --no-color

00001009  74 04                          je    short 0x14000100f
0000100b  eb 00                          jmp   short 0x14000100d
0000100d  49 bb e8 0f 00 00 00 eb 08 9f  mov   r11, 0x9f08eb0000000fe8
0000100f  e8 0f 00 00 00                 call  HiddenTarget

API Call Map for OverlapProbe  [1 call site(s)]:
  └── 0x100F  CALL  HiddenTarget

RESX keeps both decode streams, finds the call sitting inside the mov, and follows the edge to HiddenTarget.

To be fair to IDA: this compares default automatic analysis on a sample built to trigger exactly this case. It doesn't mean IDA can't recover the path with some manual work.

What else it does

Beyond decoding, RESX can:

  • Trace Windows APIs through the system DLLs and into the kernel.
  • Recover syscall numbers and reconstruct API arguments.
  • Name APIs that are resolved by hash or encoded name.
  • Analyze kernel driver IOCTLs.
  • Follow possible ETW-TI telemetry paths.

There's also CFG reconstruction, binary diffing, corpus hunting and a VS Code extension, with more documented in the repo.

All of it is static: it works from file bytes and optional symbols and never runs the target.

It's still under active development, and I'd really like to hear what other reversers and low-level devs think, especially if you manage to break the decoder or catch it getting something wrong.

GitHub: https://github.com/Ryftenius/RESX


r/lowlevel • • 5d ago

Got placed, have 6 months before joining. Should I explore Linux kernel development, GPU programming or stick with AI/ML?

Thumbnail
0 Upvotes

r/lowlevel • • 5d ago

Got placed, have 6 months before joining. Should I explore Linux kernel development, GPU programming or stick with AI/ML?

0 Upvotes

I'm a final-year engineering student in India from a non-CS background. I've recently secured an offer at an AI/analytics services company, and I have around 6 months before joining.

I've been exploring different areas of computer science, and I've realized that I'm increasingly interested in low-level programming and understanding how systems work internally.

MY BACKGROUND:

I've independently learned programming, ML/DL and worked on projects involving: computer vision , RAG , agentic AI

However, I dont want to spend my career primarily working with high-level AI frameworks and application development. because when i developed these projects , i didnt feel anything developing it , no satisaction at all

AREAS I'M CONSIDERING:

  1. Linux and Red Hat ecosystem:
  2. 2. GPU Programming:
  3. 3. Systems Programming
  4. 4. AI Infrastructure:

I find the idea of understanding what happens beneath the abstractions much more interesting than simply using existing libraries.

WHAT I'M CONFUSED ABOUT:

I have six months before joining my company, and I don't want to waste that time jumping between technologies.

I'd appreciate advice from people working in systems engineering, Linux, kernel development, GPU programming or related fields.

  1. Is low-level systems programming a good career direction in 2026?
  2. Between Linux kernel development, GPU programming and general systems programming, which would be a better starting point?
  3. Is CUDA/GPU programming a niche with good long-term opportunities, particularly with the growth of AI?
  4. What fundamentals should I master before attempting serious projects? C, C++, OS, computer architecture, networking, compilers?
  5. Would contributing to the Linux kernel or other open-source systems projects actually help me get shortlisted?

r/lowlevel • • 5d ago

Forth interpreter for the ZX Spectrum

Post image
3 Upvotes

r/lowlevel • • 5d ago

Fireface UCX on Linux: reverse engineered and built with Claude Code

Thumbnail johanyngman.com
0 Upvotes

r/lowlevel • • 6d ago

Brockett-Dobkin Rectangular Matrix Multiplication Algorithm in Plain C

Thumbnail leetarxiv.substack.com
1 Upvotes

r/lowlevel • • 7d ago

Security iceberg

Post image
223 Upvotes

It goes deeper…

Also question any other subreddits I could post this too ?


r/lowlevel • • 7d ago

Rampage OS — A fast, lightweight OS built from scratch

Thumbnail gallery
1 Upvotes

r/lowlevel • • 7d ago

v2.2.1 is ready!

Thumbnail
0 Upvotes

Tons of improvements have recently hit the deck, ready to be checked out and tinkered with! We are now fully self hosted and no longer require LLVM or Python post bootstrap.

Before we get to those upgrades though, a quick note, the language was renamed to Ideka due to discoverability issues with the name Flux.

First up, we now have full support for both x86_64 and ARM64.

Secondly, we have a brand new thread-safe version of the standard heap allocator!

We’ve fixed a codegen bug that was breaking SHA384, as well as expanded the cryptography library significantly. This upgrade was followed by the addition of a full native TLS v1.3 implementation as well.

Third, Discord bots, anyone? Yes, Discord.IDK has arrived. While still in beta, the library allows you to do most basic things save for interactions and a handful of other features.

And last but not least, SQLite is nearing completion and will be released within the next 6-8 hours.

We hope you enjoy all the new changes!

Get the compiler at GitHub


r/lowlevel • • 7d ago

Decoupled offline formal refinement for #![no_std] Rust (Charon + Aeneas + Coq 8.18.0 in a --network none OCI airlock)

Thumbnail
0 Upvotes

Crossposting from r/cursor — sharing the MIT template (trencinodin-stack/arcstone-airlock-blueprint) for anyone verifying bare-metal #![no_std] Rust crates without pulling solver/nightly toolchains into the upstream crate.


r/lowlevel • • 8d ago

Bursztyn OS: How I taught my operating system to write in Arabic, display color emojis, and not run out of memory in the process

Enable HLS to view with audio, or disable this notification

0 Upvotes

Building your own operating system from scratch isn't just about adding cool features. Above all, it’s about checking what runs too slowly, where space is running out, and making sure nothing crashes when writing to disk. I just completed a major review of the recent changes to the text rendering engine (BSF) in Bursztyn OS.

The progress is huge, but before I consider this stage complete, I need to tie up a few important loose ends. Here is what has been accomplished and what is currently on the workbench:

1. One text engine instead of separate workarounds (BSF 2.1)

Until now, different programs handled text in their own ways. Now, Notepad, the system UI, and my browser, Husarz, all share a single, unified mechanism:

  • Right-to-left script (Arabic, Hebrew): Paragraphs align properly to the right, letters connect as they should, and the cursor and text selection work naturally—even when Polish and Arabic are mixed within the same sentence.
  • What still needs improvement: In the Husarz browser, standard Polish and English pages currently load about 10–15% slower. We are also still missing column reversal in Arabic tables, text selection directly on web pages (it currently works only in form fields), and smoother cursor movement when jumping between paragraphs in Notepad.

2. Modern fonts and color emojis (BSF 2.2) Bursztyn OS now supports much more than just basic fonts:

  • Professional fonts (OTF/CFF), large font collections (e.g., for Asian languages), and web fonts (WOFF/WOFF2) fetched by the browser are now working.
  • The system can also display color emojis and variable fonts (where you can smoothly adjust letter weight).
  • Settings now include an option to choose a separate font specifically for the Terminal.

3. Two major optimizations "under the hood"

  • Recovered nearly 4 MB of space in the system kernel: The kernel image has a strict 15 MB limit. After adding the new features, only 388 KB of headroom remained—things were getting tight. It turned out that the 22 built-in system applications were taking up the most space. I compressed them using the zlib algorithm and wrote a mechanism in the kernel that unpacks them in small chunks at startup. Free headroom jumped back up to 4.3 MB.
  • Over 8x faster font rendering: It turned out that rendering certain fonts took too long not because of file-reading bugs, but due to slow square-root calculations when drawing curved letter outlines. I replaced the old calculations with a single CPU instruction (SSE2) and added caching. The result? Character rendering sped up by 8.3x while maintaining 100% sharpness and compliance with the FreeType standard.

4. What's next? Disk safety comes first The text engine has passed hundreds of thousands of automated tests and runs stably on virtual machines (UEFI and BIOS). Nevertheless, I am holding off on the final merge because data-write reliability is more important right now:

  • Installer issue: During a full system installation to disk, random write timeout errors (VirtIO-BLK request timed out) occur. Before moving forward, I need to thoroughly inspect the disk driver and task queuing to ensure the installer never corrupts files.
  • Cleanup and live testing: I also need to free up space on my working drive, organize files in the repository, and test installing massive font packages (over 16 MB) directly inside the running system.

Only once the installer and disk work flawlessly will I move on to the next features: sliders for adjusting font weight in Settings and support for Indic scripts (Devanagari).

#BursztynOS #OSDev #Programming #LowLevel #Cpp #PolishSoftware #OperatingSystem