Dos Based C, C++ developer. (old school games, no unity or modern developers please)
Budget: $750 – $1,500 AUD
Preemptive Multitasking Developer for DOS-Based Aura GUI Project
WARNING: If you lack experience with DOS-based operating systems, DO NOT apply. This is a retro project, not modern development. Applications mentioning Unity, Unreal, or similar will be ignored.
We are seeking one skilled developer to join our team for an open-source DOS-based graphical user interface (GUI) project, the Aura GUI, requiring expertise in preemptive multitasking, threading, and legacy system development. You must be proficient in C, C++, and comfortable working with virtual machines (e.g., DOSBox) and real DOS environments (e.g., bootable USB sticks) for development and testing. The project is built on Linux, cross-compiled for DOS, Windows, and Linux (i586 + x64), using Allegro 4.4.3.
Project: Aura GUI (Open-Source DOS Graphical User Interface)
Contribute to an open-source project building a graphical user interface for DOS, inspired by retro operating systems. The Aura GUI aims to support multitasking applications with a robust preemptive threading system, event handling, and modular architecture. We’ve started implementing preemptive multitasking using the Lightweight Process (LWP) library, but the implementation is incomplete and unstable, requiring an expert to finalize and stabilize it.
Responsibilities:
Complete the preemptive multitasking kernel for Aura GUI:
Enhance the LWP-based threading system (lwp.c, thread.c) to fully support preemptive scheduling using IRQ0 (timer) and IRQ8 (RTC) interrupts for task switching.
Implement robust context-switching logic for involuntary thread preemption.
Develop a priority-based scheduler to manage thread execution, ensuring responsive GUI performance.
Stabilize and debug the threading system:
Resolve known threading bugs, particularly in the widget system (widget.c), where sections are disabled due to instability.
Ensure thread safety for GUI components (e.g., windows, widgets) during rendering and event handling.
Enhance the event system:
Build a thread-safe message bus (mbus.c) for efficient communication between GUI components.
Integrate event handling (events.c) with the preemptive scheduler to process user inputs and system events.
Implement synchronization primitives:
Finalize and test semaphores and mutexes (lwp.c) for thread-safe access to shared resources.
Ensure compatibility with GUI operations, such as widget updates and event dispatching.
Develop a modular kernel architecture:
Create a module loader for dynamically loading GUI components or drivers (extend dynld.c).
Define interfaces for module registration, initialization, and communication.
Ensure modules operate safely within the preemptive multitasking environment.
Integrate external libraries with threading support:
Optimize CURL for DOS for threaded HTTP requests to enable web integration.
Implement PDCurses for terminal-based internal applications, ensuring thread safety.
Enhance LibXML2 for parsing web content in a threaded context.
Test and validate:
Conduct stress tests in DOSBox and real DOS hardware to ensure stability under heavy multitasking.
Verify GUI responsiveness and thread safety across all components.
Current State (As of April 9, 2025):
Preemptive Multitasking (Started, ~40% Complete):
Initial preemptive multitasking is implemented using LWP (lwp.c, thread.c), with interrupt hooks (_lwpPmIrq0TimerHook, _lwpPmIrq8TimerHook) for scheduling.
Thread creation (lwpSpawn), termination (lwpKill), and yielding (lwpYield) are functional, but the scheduler lacks full preemption logic.
Context switching and priority-based scheduling are partially implemented but unstable.
Threading Infrastructure:
Thread management is in place (thread.c), with a thread list (Threads) for bookkeeping.
Dedicated threads exist for timers (timer.c), events (events.c), and tasks (tasks.c), but they rely on incomplete preemption.
Event System:
A basic event thread (EventsThread in events.c) polls events, but it’s not fully integrated with preemptive scheduling.
A thread-safe message bus (mbus.c) is implemented but needs optimization.
Synchronization:
Semaphores and mutexes are partially implemented (lwpCreateSemaphore, lwpCreateMutex in lwp.c), but require testing and refinement.
Task System:
A task scheduler (tasks.c) manages callbacks via a linked list (TaskList), running in a dedicated thread (RunTasks), but it’s not fully preemptive.
Libraries:
CURL, PDCurses, and LibXML2 are partially integrated but lack threading support.
Known Issues:
Threading bugs in widget.c (disabled sections) cause instability.
Preemption is incomplete, leading to potential responsiveness issues.
Modular architecture is absent; the task system is not a true module loader.
Required Skills and Experience:
Expertise in C and C++ for low-level system programming.
Deep understanding of DOS (memory management, interrupts, real-mode programming).
Experience with preemptive multitasking:
Implementing IRQ-driven schedulers (IRQ0/IRQ8) and context switching.
Building thread-safe event systems, semaphores, and mutexes.
Familiarity with legacy libraries:
CURL for DOS: Threaded HTTP requests.
PDCurses: Terminal-based applications.
LibXML2: XML/HTML parsing in a threaded environment.
Cross-compilation on Linux for DOS, Windows, and Linux targets.
Testing on DOSBox and real DOS hardware (e.g., bootable USB sticks).
Debugging skills for low-level threading and GUI issues.
What We Provide:
Partially implemented codebase, including:
Preemptive multitasking kernel with LWP (lwp.c, thread.c).
Event, task, and widget systems (events.c, tasks.c, widget.c).
Reference implementation without threading for comparison.
Documentation for LWP and integrated libraries.
Access to team collaboration tools and version control.
Competitive budget for a skilled developer with these niche skills.
Why Join Us?
The Aura GUI is an ambitious open-source project pushing the boundaries of DOS with a modern multitasking GUI. It’s a chance to work on a unique retro system, solve complex threading challenges, and contribute to a growing community. We’re looking for someone passionate about legacy systems, eager to stabilize and enhance our preemptive kernel, and collaborative in a small team.
]Note: Include relevant DOS and threading experience. Generic applications will be ignored.
WARNING: If you lack experience with DOS-based operating systems, DO NOT apply. This is a retro project, not modern development. Applications mentioning Unity, Unreal, or similar will be ignored.
We are seeking one skilled developer to join our team for an open-source DOS-based graphical user interface (GUI) project, the Aura GUI, requiring expertise in preemptive multitasking, threading, and legacy system development. You must be proficient in C, C++, and comfortable working with virtual machines (e.g., DOSBox) and real DOS environments (e.g., bootable USB sticks) for development and testing. The project is built on Linux, cross-compiled for DOS, Windows, and Linux (i586 + x64), using Allegro 4.4.3.
Project: Aura GUI (Open-Source DOS Graphical User Interface)
Contribute to an open-source project building a graphical user interface for DOS, inspired by retro operating systems. The Aura GUI aims to support multitasking applications with a robust preemptive threading system, event handling, and modular architecture. We’ve started implementing preemptive multitasking using the Lightweight Process (LWP) library, but the implementation is incomplete and unstable, requiring an expert to finalize and stabilize it.
Responsibilities:
Complete the preemptive multitasking kernel for Aura GUI:
Enhance the LWP-based threading system (lwp.c, thread.c) to fully support preemptive scheduling using IRQ0 (timer) and IRQ8 (RTC) interrupts for task switching.
Implement robust context-switching logic for involuntary thread preemption.
Develop a priority-based scheduler to manage thread execution, ensuring responsive GUI performance.
Stabilize and debug the threading system:
Resolve known threading bugs, particularly in the widget system (widget.c), where sections are disabled due to instability.
Ensure thread safety for GUI components (e.g., windows, widgets) during rendering and event handling.
Enhance the event system:
Build a thread-safe message bus (mbus.c) for efficient communication between GUI components.
Integrate event handling (events.c) with the preemptive scheduler to process user inputs and system events.
Implement synchronization primitives:
Finalize and test semaphores and mutexes (lwp.c) for thread-safe access to shared resources.
Ensure compatibility with GUI operations, such as widget updates and event dispatching.
Develop a modular kernel architecture:
Create a module loader for dynamically loading GUI components or drivers (extend dynld.c).
Define interfaces for module registration, initialization, and communication.
Ensure modules operate safely within the preemptive multitasking environment.
Integrate external libraries with threading support:
Optimize CURL for DOS for threaded HTTP requests to enable web integration.
Implement PDCurses for terminal-based internal applications, ensuring thread safety.
Enhance LibXML2 for parsing web content in a threaded context.
Test and validate:
Conduct stress tests in DOSBox and real DOS hardware to ensure stability under heavy multitasking.
Verify GUI responsiveness and thread safety across all components.
Current State (As of April 9, 2025):
Preemptive Multitasking (Started, ~40% Complete):
Initial preemptive multitasking is implemented using LWP (lwp.c, thread.c), with interrupt hooks (_lwpPmIrq0TimerHook, _lwpPmIrq8TimerHook) for scheduling.
Thread creation (lwpSpawn), termination (lwpKill), and yielding (lwpYield) are functional, but the scheduler lacks full preemption logic.
Context switching and priority-based scheduling are partially implemented but unstable.
Threading Infrastructure:
Thread management is in place (thread.c), with a thread list (Threads) for bookkeeping.
Dedicated threads exist for timers (timer.c), events (events.c), and tasks (tasks.c), but they rely on incomplete preemption.
Event System:
A basic event thread (EventsThread in events.c) polls events, but it’s not fully integrated with preemptive scheduling.
A thread-safe message bus (mbus.c) is implemented but needs optimization.
Synchronization:
Semaphores and mutexes are partially implemented (lwpCreateSemaphore, lwpCreateMutex in lwp.c), but require testing and refinement.
Task System:
A task scheduler (tasks.c) manages callbacks via a linked list (TaskList), running in a dedicated thread (RunTasks), but it’s not fully preemptive.
Libraries:
CURL, PDCurses, and LibXML2 are partially integrated but lack threading support.
Known Issues:
Threading bugs in widget.c (disabled sections) cause instability.
Preemption is incomplete, leading to potential responsiveness issues.
Modular architecture is absent; the task system is not a true module loader.
Required Skills and Experience:
Expertise in C and C++ for low-level system programming.
Deep understanding of DOS (memory management, interrupts, real-mode programming).
Experience with preemptive multitasking:
Implementing IRQ-driven schedulers (IRQ0/IRQ8) and context switching.
Building thread-safe event systems, semaphores, and mutexes.
Familiarity with legacy libraries:
CURL for DOS: Threaded HTTP requests.
PDCurses: Terminal-based applications.
LibXML2: XML/HTML parsing in a threaded environment.
Cross-compilation on Linux for DOS, Windows, and Linux targets.
Testing on DOSBox and real DOS hardware (e.g., bootable USB sticks).
Debugging skills for low-level threading and GUI issues.
What We Provide:
Partially implemented codebase, including:
Preemptive multitasking kernel with LWP (lwp.c, thread.c).
Event, task, and widget systems (events.c, tasks.c, widget.c).
Reference implementation without threading for comparison.
Documentation for LWP and integrated libraries.
Access to team collaboration tools and version control.
Competitive budget for a skilled developer with these niche skills.
Why Join Us?
The Aura GUI is an ambitious open-source project pushing the boundaries of DOS with a modern multitasking GUI. It’s a chance to work on a unique retro system, solve complex threading challenges, and contribute to a growing community. We’re looking for someone passionate about legacy systems, eager to stabilize and enhance our preemptive kernel, and collaborative in a small team.
]Note: Include relevant DOS and threading experience. Generic applications will be ignored.