NYX

📓 devlog · 2026-07-25

• added a slab allocator to manage memory allocation more efficiently, reducing fragmentation and improving performance for small objects.
• implemented a rough version of the slab with basic allocation and deallocation logic, focusing on a fixed-size object layout.
• created a sketch for the slab design, outlining the data structures needed for cache management and object tracking.
• performed multiple cleanup commits to improve code readability, removing unnecessary whitespace and standardizing formatting.
• fixed a typo in the slab implementation to ensure consistency in naming conventions across the module.
• added stubs for future slab functionality, allowing for easier expansion and integration of additional features later.

📓 devlog · 2026-07-24

• implemented paging, added core functionality for memory management, ensuring proper control flow for page allocation and deallocation.
• fleshed out paging, defined page structures and their associated metadata for efficient access patterns.
• wired up slab, integrated slab allocation with paging to optimize memory usage and reduce fragmentation.
• rough paging, established initial framework for paging algorithms, focusing on basic page replacement strategies.
• performed cleanup in various modules, removing redundant code and improving readability.
• formatted code across multiple files, ensuring consistency in style and adherence to project guidelines.
• worked on libk, progressing on utility functions to support paging and slab management.

📓 devlog · 2026-07-23

• performed general cleanup across multiple files, removed unused variables and streamlined functions for better readability.
• initiated work on libk, added initial sketches for core functions and data structures, focused on modular design.
• formatted existing code for consistency, ensured alignment with style guide across all modified files.
• stubbed out additional functions in libk, set up basic structure for future implementation, no functional changes yet.
• implemented rough drafts of key algorithms in libk, focused on establishing functional outlines and placeholders.
• added sketches for paging functionality, laid ground for memory management, still a work in progress.
• fixed multiple instances of whitespace inconsistencies, ensured code meets formatting standards.

📓 devlog · 2026-07-22

• stub libk, added initial placeholder functions to define the interface and structure for future implementation.
• sketch libk, outlined key functionalities and features expected in libk to guide further development.
• ok actually fix libk, resolved an existing issue in the libk implementation that impacted function performance.
• cleanup, removed unnecessary code and comments in multiple files to improve readability and maintainability.
• formatting, standardized code formatting across several modules to ensure consistency in style and layout.
• add pic, integrated initial assets and images required for the project, ensuring proper paths and references.
• rough libk, created a basic version of libk to provide a foundational structure for ongoing enhancements.

📓 devlog · 2026-07-21

• added rough implementation of timefmt, establishing a basic structure for time formatting functionality.
• cleaned up code formatting across several modules to improve readability and maintainability.
• created stubs for timefmt, setting up placeholder functions for future development and integration.
• fixed a typo in the timefmt module, ensuring correct naming and preventing potential lookup errors.
• began work on paging, focusing on the initial design for memory management and data access.
• started implementing libk, aiming to enhance core library functions related to kernel operations.
• tidied up libk, removing unused code and optimizing existing functions for better performance.

📓 devlog · 2026-07-20

• implemented rough version of timefmt, focusing on initial parsing logic for time strings.
• wired up timefmt to the main application flow, ensuring it integrates correctly with existing date handling.
• sketched out the overall structure of timefmt, laying the groundwork for future enhancements.
• fixed whitespace inconsistencies in several files for better readability and maintainability.
• addressed a typo in the timefmt module to prevent potential runtime errors.
• performed additional cleanup across the codebase, removing unused variables and functions.
• added a stub for timefmt to facilitate further development and testing.

📓 devlog · 2026-07-19

• implemented rough version of timefmt, focusing on initial parsing logic for time strings.
• wired up timefmt to the main application flow, ensuring it integrates correctly with existing date handling.
• sketched out the overall structure of timefmt, laying the groundwork for future enhancements.
• fixed whitespace inconsistencies in several files for better readability and maintainability.
• addressed a typo in the timefmt module to prevent potential runtime errors.
• performed additional cleanup across the codebase, removing unused variables and functions.
• added a stub for timefmt to facilitate further development and testing.

📓 devlog · 2026-07-18

• modified pic module to include initial implementation and basic structure, established interface for adding images.
• expanded functionality of pic module, incorporated methods for adding and manipulating image data.
• began initial work on timefmt module, implemented rough outline for time formatting functions.
• fixed identified issues in timefmt, corrected incorrect time string conversions and edge cases.
• performed multiple iterations and cleanups on timefmt, ensuring consistent formatting and removal of redundant code.
• addressed whitespace issues throughout the codebase, maintaining code readability and standards.
• completed additional stubs for timefmt, preparing for future enhancements and detailed functionality.

📓 devlog · 2026-07-17

• started working on the vga module, established initial structure and placeholder functions for further development.
• cleaned up existing code, focused on reducing redundant lines and improving readability across various modules.
• fleshed out vga functionality, added basic rendering capabilities and memory layout for pixel data.
• implemented a timer system, ensuring precise tracking of time intervals, adjusted allocation for timer objects.
• added stubs for pic and timefmt modules, set up basic function signatures for future implementation.
• made multiple whitespace fixes across all files to conform to coding standards and improve consistency.
• tidied up pic module, streamlined control flow and ensured compatibility with vga rendering logic.

📓  devlog · 2026-07-16 implemented serial communication module, established basic data transfer protocols and control flow.
added serial interface to the main system, allowing for external device communication.
fleshed out serial functionality, including error checking and buffer management.
wired up serial connections for data transmission, ensuring correct pin mappings and signal integrity.
sketched out io module structure, focusing on input/output handling and data processing paths.
added initial io functions, implementing basic read/write capabilities for peripheral devices.
began rough implementation of vga module, focusing on pixel data handling and display timing.

📓 devlog · 2026-07-15
implemented console, added basic input/output functionality for user interaction through standard input and output streams.
wired up console, ensured proper integration with the main application loop for event handling.
implemented blockcache, optimized data retrieval by caching frequently accessed blocks in memory.
wired up blockcache, linked it to the data storage layer to enhance read performance.
stubbed and tidied paging, established the foundational structure for memory paging without full implementation yet.
tidied serial, cleaned up the existing codebase for serial communication, improving readability and maintainability.
added serial, integrated serial port communication for external device interaction, allowing data transfer between the application and peripherals.

📓 devlog · 2026-07-14
added initial work on interrupt handling, defined basic structure for interrupt service routines.
performed code cleanup to improve readability, removed unnecessary comments and streamlined function definitions.
cleaned up formatting across several files to adhere to style guidelines, ensuring consistent indentation and spacing.
created stub implementations for interrupt handlers, laying groundwork for future development and testing.
sketched out a more detailed design for interrupt architecture, focusing on data flow and control mechanisms.
tidied up existing interrupt code, organized functions, and reduced duplication in the implementation.
continued refining interrupt handling logic, addressing edge cases and ensuring proper allocation of resources.

📓 devlog · 2026-07-13
added stub interrupts to initialize interrupt handling in the system, setting up for further implementation.
created a work-in-progress blockcache module, laying the groundwork for efficient data storage and retrieval.
implemented the timer functionality, ensuring accurate time tracking within the system for scheduling tasks.
cleaned up various modules including blockcache and interrupts, improving readability and maintainability of the code.
fleshed out timer implementation details, refining the control flow for better performance in timing operations.
performed multiple formatting fixes across files for consistent coding style, aiding in future collaboration.
organized and tidied blockcache code, improving memory layout and preparing it for future enhancements.

📓 devlog · 2026-07-12
cleaned up interrupt handling code, focused on reducing redundancy and improving readability without changing functionality.
implemented stubs for interrupt functions to facilitate future development, allowing for easier testing and integration.
performed multiple whitespace fixes throughout the codebase to maintain consistency in style, improving overall readability.
formatted code to align with the project’s style guide, ensuring uniformity across various modules and files.
addressed various cleanup tasks, removing unused variables and optimizing import statements for better organization.
worked on interrupt-related functionality, marked as work in progress, which requires further testing and validation.
applied additional tidying to interrupt handling to ensure clear control flow and efficient resource management.

📓 devlog · 2026-07-11
added basic interrupt handling, defined interrupt vectors and handlers for specific events, ensuring correct execution flow.
cleaned up existing code, removed unused variables and streamlined function definitions for better readability and maintainability.
implemented rough interrupt logic, focused on initial data capture and processing for incoming signals from hardware.
tidied up the interrupt code, organized structure for clarity, and ensured consistent naming conventions across handlers.
performed multiple whitespace fixes and formatting adjustments, ensuring adherence to style guidelines throughout the project.
worked in progress on interrupt functionality, laying groundwork for future enhancements and optimizations in response handling.

📓 devlog · 2026-07-10
implemented wiring for idt, ensuring proper interrupt handling flow.
created initial sketches for gdt, focusing on data structure layout and alignment.
performed multiple whitespace fixes across files for improved readability.
refined gdt implementation with rough and tidy stages, optimizing memory layout.
wired up gdt, enabling segment-based memory management for the system.
cleaned up interrupt wiring, enhancing control flow during interrupt processing.
standardized formatting across the codebase to maintain consistency and clarity.

📓 devlog · 2026-07-09
fleshed out README content to provide clearer project guidelines and usage instructions, improved overall clarity.
made multiple formatting adjustments across the README files to ensure consistency and readability.
started and wired up the initial draft of the interrupt descriptor table (idt), focusing on basic structure and future implementation.
added stubs for idt functions, preparing for further development while ensuring initial code integrity.
corrected a typo in the idt implementation, ensuring accurate naming conventions in the codebase.
performed cleanup tasks on both README and idt files, removing redundant lines and improving organization.