Roadmap

AXL Roadmap

Unified phase tracker for the AXL library and SDK. Phases from AXL-Design.md and AXL-SDK-Design.md are combined here in execution order.

Legend: [x] done, [ ] pending, [-] in progress

Library Phases (AXL-Design.md)

Phase R: Rename UdkLib to AXL — DONE

  • [x] Global symbol rename (UDK_ -> AXL_, Udk -> Axl)

  • [x] Directory and header renames

  • [x] Update all consumer repos (uefi-devkit, httpfs, softbmc, ipmitool)

Phase S1: axl_mem — DONE

  • [x] axl_malloc / axl_free / axl_realloc / axl_calloc

  • [x] axl_strdup / axl_memdup

  • [x] Debug features: fill patterns, fence checks, leak dump, stats

Phase S2: axl_strbuf — DONE

  • [x] AxlStrBuf string builder

  • [x] UTF-8 / UCS-2 conversion

  • [x] Base64 encode/decode

  • [x] axl_strlcpy / axl_strlcat

  • [x] axl_asprintf

Phase S3: axl_io — DONE

  • [x] AxlStream abstraction (console, file, buffer)

  • [x] axl_printf / axl_fprintf / axl_print / axl_printerr

  • [x] axl_fopen / axl_fread / axl_fwrite / axl_readline

  • [x] axl_file_get_contents / axl_file_set_contents

Phase S4: AXL_APP — DONE

  • [x] Entry point macro: int main(argc, argv)

  • [x] Shell argument conversion (UCS-2 to UTF-8)

  • [x] axl.h umbrella header (self-contained, no EDK2 leaks)

Phases M1-M6: Module Migration — DONE

  • [x] M1: AxlLog — GLib-style logging API

  • [x] M2: AxlData — hash, array, string, JSON

  • [x] M3: AxlUtil — file, path, args, hexdump, time, smbios

  • [x] M4: AxlLoop — event loop, timers

  • [x] M5: AxlTask — arena allocator, worker pool

  • [x] M6: AxlNet — TCP, HTTP server/client, URL parsing

Phase C1: Style Guide Compliance — DONE

  • [x] STATIC -> static, TRUE -> true, FALSE -> false, BOOLEAN -> bool

  • [x] Spaces around operators, ///< doc comments

  • [x] All axl-*.c files pass style audit

Phase C2: Dogfooding — DONE

  • [x] Replace AllocatePool/FreePool with axl_malloc/axl_free in migrated modules

  • [x] Replace AsciiStrLen/AsciiStrCmp with axl_strlen/axl_strcmp

  • [x] Replace CopyMem/ZeroMem with axl_memcpy/axl_memset

  • [x] Replace AsciiSPrint with axl_snprintf

  • [x] AXL_LOG_DOMAIN in all modules

  • [x] Consumer projects updated (uefi-devkit, httpfs)

Phase C3: Test Modernization — DONE

  • [x] Shared test header (axl-test.h)

  • [x] All 9 test files converted to AXL_APP entry points

  • [x] Wide-string test output replaced with axl_printf

  • [x] Test .inf files updated (_AxlEntry, AxlAppLib)

  • [ ] Consumer build verification in test-axl.sh (httpfs, uefi-devkit)

Phase C4: Style Compliance Pass 2 — DONE

  • [x] Add Doxygen @brief/@return to all existing functions

  • [x] Multi-line params with ///< on all function definitions

  • [x] Replace remaining UEFI types with standard C in non-backend code

  • [x] Remove unnecessary #include <Uefi.h> from abstracted files

Phase C5: GLib API Alignment — DONE

Audit all public APIs against GLib naming and align before the API stabilizes. AXL is “GLib for UEFI” — the API should feel familiar to anyone who knows GLib.

  • [x] Audit every public function name against GLib equivalents

  • [x] Audit argument order (GLib puts the “object” first)

  • [x] Audit return conventions (GLib returns the modified list head from list ops)

  • [x] Rename AxlStrBuf → AxlString / axl_string_* (matches GString)

  • [x] Rename AxlHash → AxlHashTable / axl_hash_table_* (matches GHashTable)

  • [x] Swap axl_strjoin arg order to (separator, arr) matching g_strjoinv

  • [x] axl_string_new(init) takes optional init string matching g_string_new

  • [x] axl_string_append_c (was putc), axl_string_append_len (was append_n)

  • [x] Add GLib string search/test functions (strstr_len, strrstr, has_prefix, has_suffix, etc.)

  • [x] Add str_equal, strncasecmp, strv_contains, strv_equal

  • [x] AxlHashTable: generic keys, insert/replace/lookup/contains/steal/foreach_remove/iterator

  • [x] AxlHashTable: drop _w API, add AxlDestroyNotify, AxlHashFunc, AxlEqualFunc

  • [x] Update all consumers (tests, examples, httpfs)

Resolved divergences:

AXL (before)

AXL (after)

GLib equivalent

Status

AxlStrBuf / axl_strbuf_*

AxlString / axl_string_*

GString / g_string_*

DONE

AxlHash / axl_hash_*

AxlHashTable / axl_hash_table_*

GHashTable / g_hash_table_*

DONE

axl_hash_table_set/get

axl_hash_table_insert/replace/lookup

g_hash_table_insert/replace/lookup

DONE

string-only keys + _w API

generic keys via new_full(hash, equal, ...)

g_hash_table_new_full(...)

DONE

(missing)

axl_hash_table_contains/steal/foreach_remove

g_hash_table_contains/steal/foreach_remove

DONE

(missing)

AxlHashTableIter

GHashTableIter

DONE

axl_strbuf_putc

axl_string_append_c

g_string_append_c

DONE

axl_strbuf_append_n

axl_string_append_len

g_string_append_len

DONE

axl_strjoin(arr, sep)

axl_strjoin(sep, arr)

g_strjoinv(sep, arr)

DONE

(missing)

axl_strstr_len

g_strstr_len

DONE

(missing)

axl_str_has_prefix/suffix

g_str_has_prefix/suffix

DONE

(missing)

axl_strcmp0

g_strcmp0

DONE

(missing)

axl_str_equal / axl_str_hash

g_str_equal / g_str_hash

DONE

(missing)

axl_strv_contains/equal

g_strv_contains/equal

DONE

Intentional divergences (keeping):

AXL

GLib

Why

axl_fopen/axl_fread

GIOChannel

POSIX names are universal

axl_loop_new

g_main_loop_new

Shorter, UEFI has one loop

axl_strsplit(s, char)

g_strsplit(s, string, max)

Single-char delimiter sufficient

axl_dir_read returns struct

g_dir_read_name returns string

Struct has size+is_dir metadata

size_t for sizes

guint

More correct on 64-bit

int error returns

abort-on-OOM

UEFI must handle OOM

axl_dir_open

g_dir_open

OK (matches)

axl_dir_read

g_dir_read_name

Evaluate: return name only vs struct?

SDK Phases (AXL-SDK-Design.md)

SDK Phase 1: Core — DONE

  • [x] install.sh: build library, package SDK

  • [x] axl-crt0.c: UEFI entry point stub

  • [x] axl-cc: command-line build wrapper

  • [x] axl.cmake: CMake integration

  • [x] hello.c example verified in QEMU

  • [x] X64 architecture support

SDK Phase 2: Polish — DONE

  • [x] AARCH64 cross-build support (EDK2 build + tests + SDK + axl-cc aa64)

  • [x] Test CMake build end-to-end (verified in QEMU)

  • [x] Verify net module works (SDK includes AxlNetLib + all protocol GUIDs via sdk-ref target)

  • [x] Better error messages in axl-cc (source validation, tool checks, install hints)

  • [x] --verbose flag for axl-cc

  • [x] axl-cc --version / axl-cc --help

SDK Phase 3: Distribution

  • [ ] GitHub Actions: build SDK on push, publish release tarballs

  • [ ] Versioned releases (axl-sdk-0.1.0-x64-linux.tar.gz)

  • [ ] Version stamp in axl-cc output

  • [ ] Release notes automation

SDK Phase 4: Advanced Features

  • [ ] Multi-file projects in axl-cc (already works, untested)

  • [ ] axl-cc --net flag to link net module with extra GUIDs

  • [ ] axl-cc --type driver|runtime for DXE/runtime driver targets

  • [ ] axl-cc --entry <name> for custom driver entry points

  • [ ] Debug build support (axl-cc --debug)

  • [ ] Strip/optimize for release (axl-cc --release)

  • [ ] QEMU test runner integration (axl-cc --run)

SDK Phase 5: Backend Abstraction (EDK2 + gnu-efi)

Phase 5a: Backend header + EDK2 impl + core module migration — DONE

  • [x] Create axl-backend.h (internal backend abstraction API)

  • [x] Create axl-backend-edk2.c + AxlBackend.inf (EDK2 implementation)

  • [x] Self-implement portable replacements (hex parser, strcasecmp, CAS, CpuPause)

  • [x] Migrate axl-mem.c to AxlBackend API

  • [x] Migrate AxlLogLib (axl-log.c, axl-log-ring.c, axl-log-file.c)

  • [x] Migrate AxlIOLib (axl-io.c, axl-io-file.c)

  • [x] Migrate AxlDataLib (axl-string.c, axl-hash.c, axl-str.c, axl-json-print.c)

  • [x] Migrate AxlUtilLib (axl-time.c, axl-smbios.c)

  • [x] Migrate axl-arena.c (portable replacements)

  • [x] Update all .inf files to depend on AxlBackendLib

  • [x] 346 tests pass (no regression)

Phase 5b: gnu-efi backend implementation + build system — DONE (x86_64)

  • [x] Create axl-backend-gnuefi.c (gnu-efi implementation)

  • [x] Create Makefile.gnuefi for gnu-efi build (follows OSDev wiki conventions)

  • [x] Create gnu-efi CRT0 / entry point (efi_main → _AxlEntry bridge)

  • [x] axl-smbios.h/c: conditional EDK2/gnu-efi SMBIOS support

  • [x] hello.c builds and runs in QEMU with gnu-efi backend (x86_64)

  • [ ] AARCH64 gnu-efi support (requires cross-compiled gnu-efi-devel or building gnu-efi from source)

Phase 5c: Event loop + networking migration — DONE

  • [x] Migrate axl-loop.c to AxlBackend API (events, timers)

  • [x] Migrate axl-task-pool.c to AxlBackend API (MP services, single-core fallback on gnu-efi)

  • [x] Migrate axl-tcp.c, axl-net-util.c to AxlBackend API (axl_efi_call macro)

  • [x] Define missing gnu-efi protocols (DNS4, IP4Config2, ServiceBinding compat headers)

  • [x] Networking compiles and runs in QEMU on both backends

Phase 5d: Full test suite on both backends — DONE

  • [x] All 9 test binaries pass on gnu-efi (343 passed, 0 failed)

  • [x] All 9 test binaries pass on EDK2 (346 passed, 0 failed)

Phase 5e: Build/test infrastructure for dual backends — DONE

  • [x] build.sh --backend gnuefi — build library with gnu-efi

  • [x] install.sh --backend gnuefi — package gnu-efi SDK with axl-cc

  • [x] test-axl.sh --backend gnuefi — 343 passed, 0 failed (9 of 9 test binaries)

  • [x] Retired test-gnuefi.sh (now wrapper around test-axl.sh)

  • [x] Fixed libefi.a ABI mismatch (SetMem/CompareMem/StrnCpy use mixed ABI internally)

  • [x] EDK2 compat headers for tests (BaseMemoryLib, BaseLib, PrintLib, ShellLib)

  • [x] Backend-specific ratchet baselines

Native UEFI Backend (AXL-Native-Backend-Design.md)

Eliminates EDK2 and gnu-efi dependencies entirely. AXL provides its own UEFI type definitions, CRT0, and build toolchain. Supports all three UEFI image types: applications, boot service drivers, and runtime drivers.

Project Restructure — DONE

  • [x] Standard C project layout: include/ + src/ at root

  • [x] EDK2 metadata isolated in AxlPkg/ (.dsc/.dec only)

  • [x] Tests moved to test/unit/ + test/integration/

  • [x] All builds verified: EDK2 411/411, gnu-efi 411/411

Phase N1: UEFI type headers — DONE

  • [x] Create include/uefi/ with 7 self-contained headers (1540 lines)

  • [x] Types, status codes, system tables, protocols, GUIDs from UEFI 2.10

  • [x] Compiles clean on x86_64 and AARCH64 (-Wall -Wextra -Wpedantic)

Phase N2-N4: Native backend + CRT0 + tests — DONE

  • [x] Create src/backend/native/axl-backend-native.c (37 backend functions)

  • [x] Create src/crt0/axl-crt0-native.c (app entry point)

  • [x] Add AXL_BACKEND_NATIVE case to axl-backend.h

  • [x] Makefile.native — clang + lld-link, builds libaxl.a + all test EFIs

  • [x] 411/411 tests pass on native backend (full EDK2 parity)

  • [x] Remove EDK2 header dependencies from unit tests

  • [x] Delete compat shim layer (12 files, -377 lines)

  • [x] Backend directory restructure (gnuefi/, native/ subdirs)

  • [ ] Type remaining BS slots for drivers (InstallProtocolInterface, etc.)

  • [ ] Add EFI_DRIVER_BINDING_PROTOCOL to protocols header

  • [ ] Shell argument parsing (EFI_SHELL_PARAMETERS_PROTOCOL)

Phase N5: SDK integration — DONE

  • [x] Update install.sh to support native backend

  • [x] Generate axl-cc that uses native backend

  • [x] axl-cc --type driver|runtime support

  • [x] CMake integration for SDK consumers

  • [x] Test: axl-cc hello.c -o hello.efi with zero external deps

Phase N6: UEFI header generation from spec HTML — DONE

  • [x] Manifest-driven generator (scripts/generate-uefi-headers.py)

  • [x] Manifest (scripts/uefi-manifest.json): 275 definitions, dependency-ordered

  • [x] Spec downloader (scripts/download-uefi-specs.py): UEFI 2.11, PI 1.8, ACPI 6.5, Shell 2.2

  • [x] Extracts from <pre> blocks (struct, enum, funcptr, define, typedef) and Table 2-4

  • [x] Unknown struct member types auto-replaced with void *

  • [x] 327 GUIDs with EDK2-style aliases

  • [x] --check flag validates source code against manifest (integrated into build.sh)

  • [x] Shell protocols hand-written (PDF-only spec)

  • [ ] Add more protocols to manifest as needed (PCI, USB, HII, etc.)

Phase N7: Remove EDK2/gnu-efi backends — DONE

  • [x] Remove EDK2 backend (AxlPkg/, .inf files, axl-backend-edk2.c, deps.conf)

  • [x] Remove gnu-efi backend (Makefile.gnuefi, axl-backend-gnuefi.c, compat headers)

  • [x] Simplify axl-backend.h, axl.h, source files — remove all backend conditionals

  • [x] Simplify scripts (build.sh, install.sh, test-axl.sh, test-all.sh)

  • [x] Rename Makefile.native to Makefile

  • [x] Native backend is the only backend

Networking Phases (Future)

These phases add features to the existing AxlNet module. They use the EDK2-style internal API (Library/AxlNet.h) and can interleave with SDK phases.

Phase 8: Middleware

  • [ ] HTTP middleware / request pipeline

Phase 9: TLS Support — DONE

  • [x] TLS support via mbedTLS 3.6.3 (optional: AXL_TLS=1)

  • [x] axl_tls_generate_self_signed (ECDSA P-256)

  • [x] HTTP server HTTPS (axl_http_server_use_tls)

  • [x] HTTP client HTTPS (auto-detect https:// URLs)

Phase 10: SoftBMC Migration

  • [ ] Migrate SoftBMC to AXL networking stack

  • [ ] Use AxlAsync (Phase A2) for firmware update endpoint

  • [ ] Use AxlBufPool (Phase A1) for VNC tile buffers

BMC Access Phases (Future)

Phase B1: AxlIpmi — IPMI over KCS/SSIF

Local BMC access via IPMI. Auto-detects transport from SMBIOS Type 38. Absorbs uefi-ipmitool’s transport layer into AXL so consumer apps just call typed IPMI commands.

  • [ ] axl_ipmi_raw(netfn, cmd, req, resp) — send raw IPMI command

  • [ ] axl_ipmi_get_device_id() — BMC info

  • [ ] axl_ipmi_get_sensor_reading() — read a sensor

  • [ ] axl_ipmi_get_sdr_entry() — SDR repository iteration

  • [ ] axl_ipmi_get_sel_entry() — System Event Log iteration

  • [ ] axl_ipmi_chassis_status() / axl_ipmi_chassis_control() — power ops

  • [ ] axl_ipmi_get_fru_data() — FRU inventory

  • [ ] KCS transport (src/ipmi/axl-ipmi-kcs.c) via I/O port backend

  • [ ] SSIF transport (src/ipmi/axl-ipmi-ssif.c) via SMBus/I2C protocol

  • [ ] Auto-detection via SMBIOS Type 38

  • [ ] Backend: axl_backend_io_read8/write8 (x86 in/out instructions)

  • [ ] Backend: axl_backend_smbus_read_block/write_block (I2C protocol)

Consumer projects: uefi-ipmitool, SoftBMC EC module

Phase B2: AxlRedfish — Redfish REST client

Modern BMC access over HTTP+JSON+TLS. Built on existing AxlNet (HTTP client) and AxlJson modules. Adds Redfish session management, standard URI patterns, and typed result structures.

  • [ ] axl_redfish_connect(host, user, pass) — session with X-Auth-Token

  • [ ] axl_redfish_get/patch/post/delete() — generic resource access

  • [ ] axl_redfish_get_system_info() — model, serial, power state

  • [ ] axl_redfish_get_thermal() — temperatures, fans

  • [ ] axl_redfish_get_power() — power supplies, consumption

  • [ ] axl_redfish_get_bmc_info() — BMC firmware version, network

  • [ ] axl_redfish_chassis_reset() — power on/off/cycle

  • [ ] axl_redfish_get_event_log() — system event log

  • [ ] TLS integration (Phase 9 prerequisite or bundled)

No new backend support needed — pure HTTP+JSON+TLS.

Consumer projects: SoftBMC (client-side BMC queries), monitoring tools

Async Work Phases (Future)

Phase A1: AxlBufPool — preallocated buffer pool — DONE

  • [x] axl_buf_pool_new(count, buf_size) — allocate pool of fixed-size buffers

  • [x] axl_buf_pool_get(pool) — grab a free buffer (NULL if exhausted)

  • [x] axl_buf_pool_put(pool, buf) — return buffer to pool

  • [x] axl_buf_pool_available(pool) — number of free buffers

  • [x] axl_buf_pool_buf_size(pool) — query buffer size

  • [x] axl_buf_pool_free(pool) — release pool and all buffers

  • [x] Zero-copy design: LIFO free-stack, no memcpy on get/put

  • [x] 18 unit tests (basic, exhaustion, distinct, LIFO order, NULL safety)

Phase A2: AxlAsync — AP-offloaded async work queue — DONE

Bridges AxlTask (AP core dispatch) with AxlLoop (main loop events). Enables offloading CPU-heavy work to Application Processors while the BSP continues servicing the main loop (network, timers, UI).

  • [x] axl_async_init(max_pending) — initialize with configurable queue depth

  • [x] axl_async_submit(loop, work_fn, data, arena, done_cb) — dispatch work_fn to an AP core, fire done_cb on the BSP when complete

  • [x] Idle source polls axl_task_pool_poll(), auto-removed when idle

  • [x] Automatic single-core fallback: runs work_fn + done_cb synchronously

  • [x] Cancellation: axl_async_cancel(handle) — best-effort (suppresses done_cb)

  • [x] axl_async_pending() — query in-flight job count

  • [x] axl_async_shutdown() — drain and free

  • [x] 13 unit tests (init, submit, loop integration, cancel, pending, NULL safety)

File transfer example (firmware update):

AxlBufPool *pool = axl_buf_pool_new(4, 64 * 1024);  // 4 x 64KB

// HTTP handler receives chunks on the BSP:
void on_chunk_received(void *chunk_data, size_t len, void *ctx) {
    void *buf = axl_buf_pool_get(pool);      // grab free buffer
    axl_memcpy(buf, chunk_data, len);          // copy into pool buffer
    TransferCtx *tc = make_ctx(buf, len, offset);
    axl_async_submit(loop, verify_and_stage,  // runs on AP
                     tc, on_chunk_done, tc);  // callback on BSP
    // returns immediately — BSP keeps accepting connections
}

// Runs on AP core (no Boot Services access):
void verify_and_stage(void *arg) {
    TransferCtx *tc = arg;
    tc->crc = crc32(tc->buf, tc->len);       // CPU-heavy work on AP
    tc->status = validate_chunk(tc);
}

// Fires on BSP main loop after AP completes:
void on_chunk_done(void *arg) {
    TransferCtx *tc = arg;
    if (tc->status == OK) {
        flash_write(tc->offset, tc->buf, tc->len);  // BSP: Boot Services OK
    }
    axl_buf_pool_put(pool, tc->buf);          // return buffer to pool
    free(tc);
}

Double-buffer ping-pong pattern:

  • BSP receives data into buffer A, submits A to AP for processing

  • BSP starts receiving into buffer B while AP works on A

  • AP finishes A → done_cb fires → BSP submits B, starts receiving into A

  • Maximizes throughput: network I/O and computation overlap

AP constraints in UEFI:

  • APs cannot call Boot Services (only BSP can)

  • APs can do: memcpy, checksum, CRC, crypto, decompression, parsing

  • BSP handles: network I/O, file I/O, flash writes, protocol calls

  • ARM: cache flush needed for shared buffers (x86 is coherent)

Consumer projects:

  • SoftBMC: firmware update endpoint, bulk SMBIOS collection

  • httpfs: WebDAV PUT (large file writes to UEFI filesystem)

  • uefi-devkit: image deployment

Phase A3: AxlDefer — deferred work queue — DONE

BSP-only work queue drained by the main loop on each tick. Allows code in constrained contexts (protocol notifications, nested callbacks, interrupt-like handlers) to schedule work for “later this tick” without blocking or re-entering the loop.

  • [x] axl_defer_init() — initialize/reset the deferred work queue

  • [x] axl_defer(fn, data) — enqueue work (function + context pointer)

  • [x] axl_defer_cancel(handle) — remove pending work before it fires

  • [x] FIFO ordering: work fires in submission order

  • [x] Loop integration: queue drained at the start of each loop iteration, before timer/event sources are checked

  • [x] Fixed-capacity ring buffer (no malloc in the hot path)

  • [x] axl_defer_drain() — public drain for FUSE-style manual loops

  • [x] 8 unit tests (basic, cancel, FIFO order, re-entrant, null safety)

Example: protocol notification handler

// This runs in a LocateProtocol notify context — can't do complex
// work here, but can schedule it for the next loop tick:
void on_protocol_installed(void *ctx) {
    axl_defer(initialize_new_protocol, ctx);
}

// Runs safely on the next main loop iteration:
void initialize_new_protocol(void *ctx) {
    locate_and_configure(ctx);  // Boot Services OK here
    start_polling_timer(ctx);
}

Phase A4: AxlSignal — publish/subscribe event bus — DONE

Decouples event producers from consumers. Modules emit named signals, other modules subscribe with callbacks. The main loop dispatches signal callbacks (via AxlDefer) so handlers run in a safe context.

  • [x] axl_signal_new(name) — register a named signal

  • [x] axl_signal_connect(name, callback, data) — subscribe

  • [x] axl_signal_disconnect(handle) — unsubscribe by handle

  • [x] axl_signal_emit(name, event_data) — fire signal (deferred delivery)

  • [x] Multiple subscribers per signal (linked list, order-independent)

  • [x] Signal data: opaque void * passed to all subscribers

  • [x] Auto-create signals on first connect or emit

  • [x] 13 unit tests (basic, multi-sub, disconnect, unknown, auto-create, user_data)

  • [ ] Optional: typed signal variants with compile-time checked payloads

Example: network state change

// Network module emits when IP changes:
axl_signal_emit("ip-address-changed", &new_ip);

// Splash screen subscribes:
axl_signal_connect("ip-address-changed", splash_update_ip, NULL);

// REST API subscribes independently:
axl_signal_connect("ip-address-changed", api_update_endpoint, NULL);

// Both handlers fire on the next loop tick — neither knows
// about the other.  Adding a third subscriber (e.g., mDNS
// announcer) requires zero changes to the network module.

Consumer projects:

  • SoftBMC: decouple modules (network → splash, EC → sensors → REST API)

  • httpfs: filesystem mount/unmount notifications

  • Any multi-module UEFI application built on AXL

Graphics Phases (Future)

Phase G1: Graphics Output Protocol support

  • [x] GOP types in uefi-manifest.json (extracted from spec)

  • [x] AxlGfx module: basic framebuffer ops (fill, blit, capture)

  • [x] gfx-demo.c example

  • [x] Bitmap font renderer (8x16 VGA font, scalable)

  • [x] Text drawing API (axl_gfx_draw_text)

Phase G2: AGL (AximCode Graphics Library) — separate project

  • [ ] GTK-like widget toolkit built on AXL

  • [ ] Basic widgets: label, button, panel, list

  • [ ] Layout engine (vertical/horizontal box)

  • [ ] Input handling (keyboard + pointer via UEFI protocols)

  • [ ] Theming / color scheme support

  • [ ] Optional LVGL backend (use LVGL’s widget/rendering engine)

  • [ ] Optional native GOP backend (direct framebuffer, no LVGL dep)

  • [ ] Candidate first consumer: SoftBMC splash + local UI

Shell Integration Phases (Future)

Phase S5: Environment and working directory — DONE

  • [x] axl_getenv(name) / axl_setenv(name, value, overwrite) / axl_unsetenv(name)

  • [x] axl_get_current_dir() / axl_chdir(path)

  • [x] Type GetEnv, SetEnv, GetCurDir, SetCurDir, Execute in EFI_SHELL_PROTOCOL

  • [x] Backend: axl_backend_shell_getenv/setenv/getcwd/chdir/execute in all 3 backends

  • [x] 10 unit tests (set, get, overwrite, unset, missing, cwd, chdir)

Phase S6: System operations — DONE

  • [x] axl_reset(type) — system reset (AXL_RESET_COLD/WARM/SHUTDOWN)

  • [x] axl_map_refresh() — rescan device mappings via Shell “map -r”

  • [x] axl_driver_load/start/connect/disconnect/unload — driver lifecycle

Configuration Framework (Future)

Phase CF1: AxlConfig — unified options system

Unify command-line parsing (axl_args_*) and object configuration (axl_http_client_set) into a single system. Options are declared once as descriptors and can be set from multiple sources.

static const AxlOptDesc opts[] = {
    { "timeout.ms",    AXL_OPT_UINT, "10000", "Per-operation timeout" },
    { "keep.alive",    AXL_OPT_BOOL, "true",  "Reuse connections" },
    { "port",          AXL_OPT_UINT, "8080",  "Listen port" },
    { 0 }
};

AxlConfig *cfg = axl_config_new(opts);
axl_config_set(cfg, "timeout.ms", "30000");       // programmatic
axl_config_parse_args(cfg, argc, argv);            // command-line
size_t timeout = axl_config_get_uint(cfg, "timeout.ms");

  • [ ] AxlConfig type with typed get/set (get_uint, get_bool, get_string)

  • [ ] Option descriptors with type, default, description

  • [ ] axl_config_parse_args — populate from argc/argv

  • [ ] --help generation from descriptors

  • [ ] Type validation on set

  • [ ] Embed in HTTP client, HTTP server, TCP sockets

  • [ ] Available to consumer apps (replaces both axl_args_* and manual key-value config)

  • [ ] Option cascade: command-line overrides config overrides defaults

Trigger: when 3+ AXL types use the set/get string pattern. Currently only HTTP client uses it; HTTP server is next.

Documentation Phases (Future)

Phase D1: API reference

  • [x] Sphinx+Breathe auto-generates API docs from header comments

  • [x] docs/AXL-API-Reference.md removed (redundant with generated docs)

  • [ ] Add examples to each module section

Phase D2: Generated documentation — DONE

  • [x] Doxyfile + Sphinx + Breathe for HTML/man generation

  • [x] 16 module pages with prose overviews, code examples, UEFI glossary

  • [x] CI integration: auto-deploy to axl.aximcode.com on push (Cloudflare Pages)

  • [x] Man pages generated for all modules

Platform Abstraction (Future — coreboot support)

Separate UEFI-specific code from platform-agnostic code so AXL can target coreboot (and potentially other firmware environments) in addition to UEFI.

Current state: 29 of 47 source files are already platform-agnostic. 18 files make direct UEFI calls (87 call sites) outside the backend abstraction layer. The backend header (src/backend/axl-backend.h) defines the abstraction API but not all modules use it consistently.

Phase P1: Audit and classify modules

Categorize every source file:

  • Core (platform-agnostic): mem, format, data, str, string, json, cache, list, slist, queue, hash-table, args, config, hexdump, log-ring, defer, signal, arena, buf-pool, url, http-middleware

  • Backend-abstracted (uses backend API, not UEFI directly): io, log, loop, time, task-pool, async, io-buf, io-file, log-file

  • UEFI-coupled (calls gBS/gRT/gST/protocols directly): tcp, udp, net-util, http-server, http-client, http-core, gfx, mem (pages), driver, nvstore, service, smbios, sys, app, tls, mbedtls-platform

  • [ ] Document the classification in a table

  • [ ] Identify which UEFI calls in coupled modules should become backend functions vs. staying in a UEFI platform module

Phase P2: Expand backend abstraction

Move direct UEFI calls behind new backend functions:

  • [ ] axl_backend_locate_protocol(guid, interface) — wraps gBS->LocateProtocol, LocateHandleBuffer, HandleProtocol

  • [ ] axl_backend_alloc_pages(count, phys_addr) — wraps gBS->AllocatePages/FreePages

  • [ ] axl_backend_create_event(type, callback, ctx, event) — wraps gBS->CreateEvent/CloseEvent/CheckEvent/SignalEvent

  • [ ] axl_backend_install_protocol(handle, guid, interface) — wraps gBS->InstallProtocolInterface/UninstallProtocolInterface

  • [ ] axl_backend_get_variable / set_variable — wraps gRT->GetVariable/SetVariable

  • [ ] axl_backend_exit(status) — wraps gBS->Exit

Networking is the largest task: TCP, UDP, and HTTP use UEFI protocol calls extensively (service binding, completion tokens, Poll, Configure). Options: a) Abstract each protocol behind a backend socket API b) Keep networking as a UEFI-only module, provide a separate coreboot networking module later (Linux socket API) c) Define a portable socket API in the backend, implement for UEFI (TCP4/UDP4) and coreboot (Linux sockets) separately

Option (c) is cleanest but most work. Option (b) is pragmatic.

Phase P3: Split source tree

Reorganize into platform-agnostic and platform-specific directories:

src/
  core/          ← platform-agnostic (mem, str, data, format, log, etc.)
  platform/
    uefi/        ← UEFI backend + UEFI-specific modules
    coreboot/    ← future: coreboot backend
  net/           ← networking (may stay UEFI-specific initially)

  • [ ] Move core modules to src/core/

  • [ ] Move UEFI-specific code to src/platform/uefi/

  • [ ] Update Makefile, install.sh, and header paths

  • [ ] Verify all builds and tests pass

Phase P4: coreboot backend stub

  • [ ] Create src/platform/coreboot/axl-backend-coreboot.c

  • [ ] Implement core backend functions (console, memory, time)

  • [ ] Build libaxl-core.a (platform-agnostic subset)

  • [ ] Test core modules on coreboot (or Linux as a proxy)

Dependencies: This is a large architectural change. Should be done after the API stabilizes (post-1.0) to avoid churn during the refactor. The backend abstraction layer was designed for this split from the beginning.

Estimated effort: P1 (1 day), P2 (3-5 days), P3 (2-3 days), P4 (3-5 days). Total: ~2-3 weeks.

Repo Merge (Complete)

  • [x] Rename axl-sdk -> axl-sdk-old on GitHub

  • [x] Rename libaxl -> axl-sdk on GitHub

  • [x] Copy SDK files into merged repo

  • [x] Rework install.sh for local library

  • [x] Update docs and consumer projects