Oh no! Where's the JavaScript?
Your Web browser does not have JavaScript enabled or does not support JavaScript. Please enable JavaScript on your Web browser to properly view this Web site, or upgrade to a Web browser that does support JavaScript.

SMP is Working!

Last updated on 10 hours ago
D
danilosJunior Member
Posted 2 days ago
🚀 AROSA Milestone Reached: SMP is Working!
Today I'm happy to share that AROSA has successfully completed its first SMP (Symmetric Multi-Processing) execution.
This is an early step, but an important one. For the first time, AROSA is successfully utilizing multiple CPU cores and executing work across processors. The screenshot shows the system running with 4 logical processors active while simultaneously handling networking, web browsing, canvas rendering, and system monitoring.
You do not have access to view attachments
T
terminillsMember
Posted 1 day ago

danilos wrote:

@danilos - 🚀 AROSA Milestone Reached: SMP is Working!
Today I'm happy to share that AROSA has successfully completed its first SMP (Symmetric Multi-Processing) execution.
This is an early step, but an important one. For the first time, AROSA is successfully utilizing multiple CPU cores and executing work across processors. The screenshot shows the system running with 4 logical processors active while simultaneously handling networking, web browsing, canvas rendering, and system monitoring.


AROS has had SMP for years :x
BohunBohunDistro Maintainer
Posted 1 day ago
Does it have libraries that would allow programmers to utilize multiple cores? Programs like the ArtCraft series or browsers don't seem to use SMP?
AROS-ConfidenceAROS-ConfidenceJunior Member
Posted 1 day ago
Now we need parallel Processing and Memory Protection!
D
danilosJunior Member
Posted 1 day ago
Yes, AROS already provides APIs that can be used for multicore programming.

At the native level, Exec supports tasks, message ports, signals and synchronization primitives. The SMP implementation also provides CPU-affinity mechanisms, including KrnAllocCPUMask(), KrnGetCPUMask() and SetTaskAffinity(). There is also POSIX threading support.

So the basic mechanisms are there.

However, there is an important distinction between being able to create tasks that run on multiple CPUs and having a complete, stable, SMP-safe environment that applications can reliably exploit.

The main limitation is that not all existing AROS libraries and services are necessarily SMP-safe. For example, Forbid() only prevents task switching on the calling CPU. It does not prevent another CPU from accessing the same shared resources simultaneously. This means traditional Amiga synchronization assumptions cannot always be applied in a multicore environment.

This is particularly relevant to applications such as ArtCraft or browsers. Applications must distribute their workloads, and the operating system services they use must support concurrent execution safely.

This is one of the major objectives of AROSA, and the work involves two complementary levels.

1. Improving the underlying AROS SMP implementation

I have already made several patches to the existing AROS x86_64 SMP kernel while investigating problems encountered during AROSA testing.

The implementation can boot, initialize multiple processors and execute workloads across different CPUs. However, testing has exposed intermittent freezes, locking problems and other stability issues that still require investigation.

I'm continuing to work through scheduling, synchronization and interactions with components designed around single-processor assumptions. Further kernel changes are necessary, and I am not claiming that all these issues have been resolved.

2. Making parallel processing available through AROSA's capability architecture

AROSA is built around a capability consumer/provider model. Rather than requiring applications to depend directly on particular libraries or kernel implementations, functionality is exposed through defined capability contracts and resolved through suitable providers.

This is not merely a theoretical architecture.

ABrowser, ACanvasComposer and AFileManager are concrete examples of applications developed around this capability model. Depending on their roles, components can consume platform capabilities and provide functionality to other components.

ABrowser: Consumes networking, HTML, JavaScript, graphics and media capabilities. Suitable operations, such as decoding and processing, are candidates for parallel execution.

ACanvasComposer: Uses graphics and composition capabilities, providing a natural environment for distributing independent rendering and image-processing workloads.

AFileManager: Consumes filesystem, content and other platform services. File operations such as copying, hashing, compression and processing can potentially be organized as independent jobs.

The significance is that these applications do not each need to implement an entirely separate infrastructure for every shared function.

The same principle applies to multicore execution.

I'm developing the architecture so an application can request a parallel processing capability, submit independent workloads and receive results through a defined interface. AROSA would select an appropriate execution provider, taking account of CPU availability, scheduling requirements and the restrictions of the underlying operating system.

This should eventually allow the same application to use different execution implementations, including a single-core fallback when necessary.

The capability model also integrates with AIDEa, AROSA's application engineering environment, so applications can declare and consume capabilities as part of their composition rather than being tightly coupled to specific system implementations.

Importantly, applications and services can be both consumers and providers. This makes capabilities reusable and allows more complex applications to be assembled from independently implemented components.

However, the higher-level capability model cannot compensate for unsafe kernel behavior. Reliable multicore execution still depends on correct scheduling, locking, synchronization and SMP-safe system interfaces.

That is why I am working on both the underlying AROS kernel and the higher-level AROSA architecture.

The existing applications demonstrate the consumer/provider model, but I am not claiming that all their workloads are already executing in parallel across multiple CPUs. That remains part of the ongoing SMP integration and verification work.

Ultimately, my objective is not simply to demonstrate that AROS can run on several processors. It is to make multicore processing stable, accessible and genuinely useful to application developers.

The goal is to allow applications such as ArtCraft, ABrowser, ACanvasComposer, AFileManager and future AROSA applications to benefit from reusable execution capabilities without requiring every developer to become an expert in kernel scheduling, CPU affinity and synchronization.
T
terminillsMember
Posted 1 day ago

Bohun wrote:

@Bohun - Does it have libraries that would allow programmers to utilize multiple cores? Programs like the ArtCraft series or browsers don't seem to use SMP?


It's not libraries that are the limiting factor it's API's AROS SMP has specific API's that have worked fine for years.
T
terminillsMember
Posted 1 day ago

danilos wrote:

@danilos - Yes, AROS already provides APIs that can be used for multicore programming.

At the native level, Exec supports tasks, message ports, signals and synchronization primitives. The SMP implementation also provides CPU-affinity mechanisms, including KrnAllocCPUMask(), KrnGetCPUMask() and SetTaskAffinity(). There is also POSIX threading support.

So the basic mechanisms are there.

However, there is an important distinction between being able to create tasks that run on multiple CPUs and having a complete, stable, SMP-safe environment that applications can reliably exploit.

The main limitation is that not all existing AROS libraries and services are necessarily SMP-safe. For example, Forbid() only prevents task switching on the calling CPU. It does not prevent another CPU from accessing the same shared resources simultaneously. This means traditional Amiga synchronization assumptions cannot always be applied in a multicore environment.

This is particularly relevant to applications such as ArtCraft or browsers. Applications must distribute their workloads, and the operating system services they use must support concurrent execution safely.

This is one of the major objectives of AROSA, and the work involves two complementary levels.

1. Improving the underlying AROS SMP implementation

I have already made several patches to the existing AROS x86_64 SMP kernel while investigating problems encountered during AROSA testing.

The implementation can boot, initialize multiple processors and execute workloads across different CPUs. However, testing has exposed intermittent freezes, locking problems and other stability issues that still require investigation.

I'm continuing to work through scheduling, synchronization and interactions with components designed around single-processor assumptions. Further kernel changes are necessary, and I am not claiming that all these issues have been resolved.

2. Making parallel processing available through AROSA's capability architecture

AROSA is built around a capability consumer/provider model. Rather than requiring applications to depend directly on particular libraries or kernel implementations, functionality is exposed through defined capability contracts and resolved through suitable providers.

This is not merely a theoretical architecture.

ABrowser, ACanvasComposer and AFileManager are concrete examples of applications developed around this capability model. Depending on their roles, components can consume platform capabilities and provide functionality to other components.

ABrowser: Consumes networking, HTML, JavaScript, graphics and media capabilities. Suitable operations, such as decoding and processing, are candidates for parallel execution.

ACanvasComposer: Uses graphics and composition capabilities, providing a natural environment for distributing independent rendering and image-processing workloads.

AFileManager: Consumes filesystem, content and other platform services. File operations such as copying, hashing, compression and processing can potentially be organized as independent jobs.

The significance is that these applications do not each need to implement an entirely separate infrastructure for every shared function.

The same principle applies to multicore execution.

I'm developing the architecture so an application can request a parallel processing capability, submit independent workloads and receive results through a defined interface. AROSA would select an appropriate execution provider, taking account of CPU availability, scheduling requirements and the restrictions of the underlying operating system.

This should eventually allow the same application to use different execution implementations, including a single-core fallback when necessary.

The capability model also integrates with AIDEa, AROSA's application engineering environment, so applications can declare and consume capabilities as part of their composition rather than being tightly coupled to specific system implementations.

Importantly, applications and services can be both consumers and providers. This makes capabilities reusable and allows more complex applications to be assembled from independently implemented components.

However, the higher-level capability model cannot compensate for unsafe kernel behavior. Reliable multicore execution still depends on correct scheduling, locking, synchronization and SMP-safe system interfaces.

That is why I am working on both the underlying AROS kernel and the higher-level AROSA architecture.

The existing applications demonstrate the consumer/provider model, but I am not claiming that all their workloads are already executing in parallel across multiple CPUs. That remains part of the ongoing SMP integration and verification work.

Ultimately, my objective is not simply to demonstrate that AROS can run on several processors. It is to make multicore processing stable, accessible and genuinely useful to application developers.

The goal is to allow applications such as ArtCraft, ABrowser, ACanvasComposer, AFileManager and future AROSA applications to benefit from reusable execution capabilities without requiring every developer to become an expert in kernel scheduling, CPU affinity and synchronization.


I've personally run llamacpp and chromium across 128 cores using dtandard AROS API's what you're doing it trying to add another layer in a sandbox to something that's already being worked on in in master.
D
danilosJunior Member
Posted 1 day ago
I think we have different goals, and they are not competing goals.

I appreciate the ongoing work on AROS SMP and have no intention of duplicating or diminishing anyone else's efforts.

AROSA is my contribution toward a broader multi-user, multiprocessing, capability-based application and service platform, building on AROS and extending it where necessary.

During development, I have encountered several issues in the x86_64 SMP kernel and have made a number of patches while investigating and correcting them. Some stability issues remain under investigation.

I'm happy to contribute these kernel fixes back to AROS if the developers are interested. I don't know whether I have permission to contribute directly to the repository, but I can certainly make the patches available for review and integration.

I've invested considerable time in AROSA over the past six months, and I'm sharing the work because I believe it could benefit the community.

There is room for different approaches, and I see no reason why they cannot complement each other.

Ultimately, we all want AROS to progress, and I would much rather spend my time developing, testing and sharing improvements than debating competing approaches.
C
coffeecatSoftware Dev
Posted 1 day ago
You're both right. Terminills’s Chromium example shows that AROS can run threads across many cores. My experience with another-browser raised a different question: how quickly does a worker actually get CPU time when it has work? In my test, adding cores alone didn’t give me a speedup. I did see an improvement after a small local kernel change, but I didn’t commit the proposal yet - I had no time to measure the impact.

There’s a concrete example in Signal(). When a worker is waiting for a signal, receiving it can make the worker ready to run. In one particular path, AROS has to choose another CPU to handle the signal. It picks the first CPU allowed by the worker’s affinity mask, without checking which one is busy. The source even says, “Use CPU balancing some day...” That choice doesn’t bind the worker to that CPU, but it raises a practical question for a browser that wakes workers frequently: how much time passes between a job becoming ready and a worker actually starting it? AROS Signal() source (https://github.com/aros-development-team/AROS/blob/58b0682b/rom/exec/signal.c #L164-L204)

That’s where I see the connection with Danilo’s proposal. AROSA would let an application submit independent jobs and leave the choice of how to execute them to a shared service. That could save each application from managing its own workers and CPU placement. As Danilos also points out, those workers still depend on the kernel to wake and schedule them efficiently. I’d be interested to see whether any of his kernel patches touch this wake-up path, and whether he measured a difference under load
Edited by coffeecat on 19-11-2026 11:20, 1 day ago
BohunBohunDistro Maintainer
Posted 1 day ago
Please explain to a layman what AROSA is? Is it a program that distributes the threads of a single-core application across multiple cores?
T
terminillsMember
Posted 1 day ago

coffeecat wrote:

@coffeecat - You're both right. Terminills’s Chromium example shows that AROS can run threads across many cores. My experience with another-browser raised a different question: how quickly does a worker actually get CPU time when it has work? In my test, adding cores alone didn’t give me a speedup. I did see an improvement after a small local kernel change, but I didn’t commit the proposal yet - I had no time to measure the impact.

There’s a concrete example in Signal(). When a worker is waiting for a signal, receiving it can make the worker ready to run. In one particular path, AROS has to choose another CPU to handle the signal. It picks the first CPU allowed by the worker’s affinity mask, without checking which one is busy. The source even says, “Use CPU balancing some day...” That choice doesn’t bind the worker to that CPU, but it raises a practical question for a browser that wakes workers frequently: how much time passes between a job becoming ready and a worker actually starting it? AROS Signal() source (https://github.com/aros-development-team/AROS/blob/58b0682b/rom/exec/signal.c #L164-L204)

That’s where I see the connection with Danilo’s proposal. AROSA would let an application submit independent jobs and leave the choice of how to execute them to a shared service. That could save each application from managing its own workers and CPU placement. As Danilos also points out, those workers still depend on the kernel to wake and schedule them efficiently. I’d be interested to see whether any of his kernel patches touch this wake-up path, and whether he measured a difference under load


The question comes down to is this already being worked on in Master ... if it is this would create two implementations... However the point isn't really about the shared service it's more acting like multicore didn't exist prior to his work which is flat out incorrect.
D
danilosJunior Member
Posted 1 day ago

coffeecat wrote:

@coffeecat - You're both right. Terminills’s Chromium example shows that AROS can run threads across many cores. My experience with another-browser raised a different question: how quickly does a worker actually get CPU time when it has work? In my test, adding cores alone didn’t give me a speedup. I did see an improvement after a small local kernel change, but I didn’t commit the proposal yet - I had no time to measure the impact.

There’s a concrete example in Signal(). When a worker is waiting for a signal, receiving it can make the worker ready to run. In one particular path, AROS has to choose another CPU to handle the signal. It picks the first CPU allowed by the worker’s affinity mask, without checking which one is busy. The source even says, “Use CPU balancing some day...” That choice doesn’t bind the worker to that CPU, but it raises a practical question for a browser that wakes workers frequently: how much time passes between a job becoming ready and a worker actually starting it? AROS Signal() source (https://github.com/aros-development-team/AROS/blob/58b0682b/rom/exec/signal.c #L164-L204)

That’s where I see the connection with Danilo’s proposal. AROSA would let an application submit independent jobs and leave the choice of how to execute them to a shared service. That could save each application from managing its own workers and CPU placement. As Danilos also points out, those workers still depend on the kernel to wake and schedule them efficiently. I’d be interested to see whether any of his kernel patches touch this wake-up path, and whether he measured a difference under load


Thank you, this is a very interesting observation, and it is much closer to the behavior I have been investigating.

During AROSA testing with four logical processors, AResourceMonitor showed CPU 0 under very heavy load while the other CPUs were active but appeared to contribute comparatively little productive work.

My impression was that some of the processors might be spending a significant amount of time participating in scheduling, synchronization or lock contention rather than executing the actual application workloads.

In other words, the CPUs may be busy coordinating or competing for work rather than doing the work itself.

Your observation about Signal() selecting the first permitted CPU without considering its current load is particularly interesting. With applications that frequently wake workers, such as browsers or rendering systems, I wonder whether that could result in excessive interprocessor signaling, repeated scheduling activity and contention around shared scheduler structures.

That might explain why adding processors does not necessarily produce a corresponding increase in useful throughput.

During the past couple of weeks, I have made several patches to the x86_64 SMP kernel, concentrating on task-state transitions, locking, scheduler interactions and interrupt handling. Some corrections have improved execution, but I am still investigating intermittent freezes.

I haven't yet established whether those changes affect the specific Signal() wake-up path you identified, nor have I measured the scheduling latency directly.

I think the important measurement is not simply how busy each CPU is, but how much of that time is spent executing useful application code versus scheduler activity, synchronization, interrupts and waiting for locks.

This is also an area where AROSA's resource monitoring and capability architecture could be useful. I want to extend AResourceMonitor to show CPU and memory consumption by application, task, service and composition, with enough kernel instrumentation to distinguish productive execution from scheduling overhead.

Your proposed wake-up latency measurement would complement that work very well.

I would be interested in comparing the results of your local scheduler change with the behavior I'm observing. It might help establish whether we are looking at related problems or two different limitations in the SMP implementation.

Ultimately, the objective is not just to have several CPUs active, but to have them executing useful work efficiently while keeping the overall system responsive.
D
danilosJunior Member
Posted 1 day ago

Bohun wrote:

@Bohun - Please explain to a layman what AROSA is? Is it a program that distributes the threads of a single-core application across multiple cores?


Thanks for asking. It's a fair question, because AROSA is considerably broader than a desktop environment or a collection of applications.

AROSA (Application Runtime Operating Services Abstraction) is a service-based application platform built on AROS.

The ambition is to continue and revive the original Amiga vision: an efficient, responsive, innovative and extensible computing environment, while bringing the platform into the 21st century.

Not simply preserving the Amiga experience, but evolving it.

AROS provides the operating-system foundation. AROSA builds on it with a common architecture of services, capabilities, providers, adapters and application composition.

The fundamental idea is that functionality should be reusable across the entire platform, rather than being implemented separately inside every application.

For example, an HTML rendering engine should not belong exclusively to a browser. A graphics engine should not belong exclusively to a drawing program. Search, cryptography, networking, content management, editing and application controls should all be available as reusable platform capabilities.

This is the basis of AROSA's capability consumer/provider architecture.

A service, library or application can request capabilities from the platform, but it can also contribute new capabilities that become available to other components.

Providers supply the implementations. Adapters connect existing libraries, technologies and alternative implementations. Capability contracts define how functionality is accessed, while composition brings the required capabilities together.

This makes it possible to extend the platform without requiring every application to understand the internal implementation of every service.

What does AROSA already contain?

There is already a growing range of implemented and partially integrated capabilities, including:

[list]
[*]Native user-interface framework: Common application windows, controls, reusable components, toolbars, menus, tabbed interfaces, listviews, treeviews, dialogs, configuration surfaces, themes, desktop personalities and shared presentation mechanisms.

[*]Editing and document components: Reusable text editing, code-oriented editing facilities, search, navigation, document presentation and HTML-based help interfaces. These are platform components rather than features tied to a single editor.

[*]Graphics and composition: Canvas drawing, vector graphics, animation, scene composition, transformations, layers, blending, procedural graphics and reusable rendering capabilities.

[*]Fractal generation and ray tracing: Fractal generation and analytic ray-rendering capabilities, with support for combining rendering technologies through composition. Work also includes integration with external scene and parameter formats such as POV-Ray and Fractint.

[*]Web technologies: HTML and CSS processing, JavaScript execution and integration with QuickJS, plus networking, document navigation, media and canvas-related functionality. These technologies are intended to serve applications beyond ABrowser.

[*]Vector and graphics libraries: Integration and adaptation of technologies such as ThorVG, NanoSVG, FreeType and other existing libraries behind reusable platform interfaces.

[*]Cryptography and secure communications: Cryptographic primitives, secure networking, TLS-related capabilities and infrastructure for protecting credentials and application data.

[*]Diagnostics and observability: Centralized logging, tracing, application diagnostics, performance measurements, resource monitoring, system stability probes and historical telemetry.

[*]Foundation and application services: Shared service registration, configuration, state management, application lifecycle, invocation, process execution, dependency handling and resource management.

[*]Identity, sessions and authorization: Users, groups, roles, process security contexts, session management, access-control services and mechanisms for controlling access to applications and resources.

[*]Content and repository services: Content repositories, metadata, versioning, search, permissions, content relationships and SQLite-backed persistence.

[*]Networking and communication: Network services, HTTP-related facilities, transfers, time synchronization and communication providers.

[*]Development and engineering: Application templates, reusable components, descriptors, capability registration and integration with AIDEa, the application engineering environment.
[/list]

These capabilities are not all at the same maturity level. Some are already operating in applications, some have implemented service contracts and providers but require further integration, and others are still being extended.

There is also a wider range of services in the architecture that are under development or planned.

The broader platform architecture

[list]
[*]Session and workspace management: Multiple users and sessions, controlled application ownership, persistent workspaces and independent user environments.

[*]Vault and security services: Encrypted secret storage, key management, credential protection, authorization policies and controlled recovery.

[*]Governance: Policies for identities, services, applications, resources, capabilities, configuration and auditing.

[*]Content management: Shared repositories with versioning, metadata, indexing, search, access policies and extensible content models.

[*]Workflow and automation: Coordinating applications, services, data and operations through reusable workflow capabilities.

[*]Isolation and virtualization: Protected execution environments, resource isolation and eventually compatibility environments for legacy Amiga and AROS software.

[*]Package management and distribution: Installation, capability discovery, dependency resolution, application registration, repositories and reusable deployment descriptors.
[/list]

Applications are both consumers and providers

ABrowser, AFileManager and ACanvasComposer are examples of applications built around this architecture, alongside administrative and monitoring applications.

However, the important point is not the number of applications.

An application can consume capabilities and, where appropriate, provide functionality that other applications or services can reuse.

For example, a rendering capability used by ACanvasComposer should also be usable by a presentation application, an animation tool or another graphics program.

An editing component used in one administration application should be available to other applications without being rewritten.

A cryptographic provider can serve networking, vaults, content repositories and other security-sensitive services.

The same principle applies to web technologies, databases, search, media processing, diagnostics and virtually every other shared function.

AIDEa and application engineering

One of the longer-term objectives is to make the platform itself an application engineering environment.

Developers should be able to build applications through conventional programming, through reusable components, or through declarative application descriptions created with AIDEa.

An application can specify the capabilities it requires and the capabilities it offers.

AROSA's composition and resolution mechanisms then connect those requirements with compatible providers.

This means the application is not necessarily tied to one graphics engine, one networking implementation, one database or one execution mechanism.

It also means that integrating a new library or technology can benefit multiple applications rather than only the program that originally introduced it.

The overall vision

I don't see AROSA as another desktop sitting on top of AROS, nor simply as a collection of applications.

It is an attempt to create a coherent application and service platform where operating-system facilities, shared technologies, development tools and applications form one extensible environment.

The Amiga was remarkable because it offered a highly integrated and efficient computing experience on limited hardware.

I believe that philosophy remains valuable, but a modern implementation also needs user and session management, security, shared content, services, graphics, networking, automation, application composition and extensible development capabilities.

The objective is to combine that modern architecture with the efficiency and responsiveness associated with the Amiga tradition.

Every new capability should potentially strengthen the entire ecosystem, not just one application.

That's the direction I'm pursuing with AROSA. It's an independent project built on AROS, with the intention of contributing the results back to the community.
ArgoArgoMember
Posted 13 hours ago
Greetings, it's good to see more people experimenting with AROS's internals. That said, I think it's worth stepping back and looking at why terminills responded the way he did, because there is a lot of active work already happening in the main codebase that seems to have been missed here.

First, it's unclear which branch you actually forked—ABIv1 (aros-development-team/AROS master) or Deadwood's ABIv11 stable snapshot (deadw00d/AROS), which intentionally holds back experimental kernel changes for hardware and application stability. If you started from an older snapshot or didn't check the active development branch, it's easy to assume SMP isn't moving when the exact opposite is true.

The core goal of AROS is preserving compatibility with AmigaOS 3.1 APIs and program expectations—making multicore execution work within that contract so existing software and native apps benefit without needing to be rewritten around a custom framework. Building a separate capability consumer/provider userland (AIDEa, ABrowser, ACanvasComposer, etc.) on top means only software built specifically against your layer can use it, which breaks compatibility with the rest of the ecosystem.

More importantly, getting all four logical cores to light up on a system monitor is only the surface layer of SMP. Once tasks are running outside Core 0, the real engineering work is juggling all the connected OS subsystems that still assume a single processor:

Memory management & coherency: Keeping shared MemHeader lists (AllocMem/FreeMem), cache coherency, and cross-CPU TLB shootdowns safe when multiple cores allocate memory and pass raw pointers in Exec messages without relying on single-core Forbid() assumptions.

Locking & kernel synchronization: Fixing per-task spinlock contention, recursive lock edge cases, and IPI handling under real multi-threaded workloads.

Scheduler topology & task rotation: Handling SMT/Hyper-Threading sibling awareness, safe task migration across cores without breaking CPU-local state, and balancing cache locality against thermal and load distribution—not just spraying independent jobs onto cores.

Most of these exact issues are actively being worked on, tested, and documented right now in the main GitHub repository ( https://github.co...-team/AROS ). Just over the last month alone, contributors like Ashahel, terminills, Nick Andrews, and Bo Ståle Kopperud have been landing and testing concrete SMP kernel fixes—per-task tc_SpinLock discipline (#1700, #1702), page-granular KrnMapGlobal with cross-CPU TLB shootdowns (#1701), SMP-MultiWake tests, scheduler/IPI fixes, and test/smp validation runs (#1726).

Even if you don't want to dig through raw git commits every day, I've been posting weekly summaries of what has actually landed in master over in the This Week in AROS thread right here on the forum ( https://www.arosw...ad_id=2153 ), alongside Deadwood's commit log updates ( https://www.arosw...ad_id=2123 ).

If you've already written patches that fix real x86_64 SMP locking bugs or kernel freezes, the best thing you can do for the project—and to get feedback from the people who know the kernel invariants inside and out—is to publish your repo/diffs, open an issue or PR against aros-development-team/AROS, and talk directly with the maintainers on GitHub or Discord. Working in isolation without upstream discussion or a public repo just ends up creating a fork nobody else can test or merge.
Edited by Argo on 20-11-2026 02:25, 13 hours ago
D
danilosJunior Member
Posted 11 hours ago
Thank you for the detailed reply and the references to the ongoing development.

First, I'd like to clarify that I have never intended to diminish or offend any of the AROS developers, nor to suggest that SMP development was not already taking place. My original announcement was simply about a milestone reached in AROSA, not a claim to have introduced SMP to AROS.

I appreciate the work being done on the underlying operating system.

I think there is still a misunderstanding about what AROSA is intended to be.

AROSA is not an alternative implementation of the AmigaOS APIs, nor is it intended to replace the existing AROS environment or break application compatibility.

It is a service-based application platform built on AROS, providing additional capabilities such as identity and session management, security, vault services, content management, workflow, resource management, graphics, application composition and integrated application engineering.

The capability consumer/provider architecture is designed to reuse existing functionality, including native AROS APIs and third-party technologies, through defined contracts and adapters.

Existing AROS applications should continue to operate normally. Applications developed specifically for AROSA can make use of the additional services, just as applications developed for other operating systems may depend on additional frameworks or libraries.

The objective is to extend the possibilities of the platform, not to replace its foundations.

Regarding the kernel, my x86_64 SMP source was obtained in early November. It was based on the active AROS development tree.

During testing, I encountered scheduling, synchronization and locking problems, which led to several kernel patches and further investigations. I have not claimed that the underlying SMP implementation was my work or that my corrections resolve every remaining issue.

As I already mentioned, I am happy to share those patches with the AROS maintainers for review and possible integration.

Regarding working independently, AROSA is a fairly substantial project that I have been developing over the past 12 months. Before presenting it publicly, I wanted to establish the architecture, implement actual services and applications, and demonstrate that the concepts could work in practice.

I did not approach other developers earlier because I had no concrete contribution or particular technical issue to discuss with them. I also had no way of knowing in advance whether the broader architectural ideas would be of interest to anyone.

Now that there are working components and kernel modifications, there are concrete opportunities for technical exchange and collaboration.

I certainly don't object to contributing upstream or discussing implementation details with the maintainers. Equally, I think there is room in the AROS ecosystem for independent development and experimentation without every project needing to follow the same architectural direction.

AROSA and the core AROS development effort have different, complementary objectives. I don't see them as competing projects.

My intention is to contribute something useful to the community, preserve compatibility with the existing environment, and help carry the original Amiga vision into a modern application platform.

I would much rather see the different efforts benefit each other than turn them into a competition.
ArgoArgoMember
Posted 11 hours ago
Glad to hear it's based on the November master tree—feel free to drop a link to your repo or open a PR on aros-development-team/AROS with those x86_64 SMP locking patches so the maintainers can take a look



"You can practice shooting eight hours a day, but if your technique is wrong, then all you become is very good at shooting the wrong way. Get the fundamentals down, and the level of everything you do will rise." - Michael Jordan
D
danilosJunior Member
Posted 10 hours ago
I just got an encouraging result yesterday, which explains my excitement and the post. Today, I submitted the patches for review.

Fair enough, but everyone needs to learn, and shooting straight takes practice too! 🙂
You can view all discussion threads in this forum.
You cannot start a new discussion thread in this forum.
You cannot reply in this discussion thread.
You cannot start on a poll in this forum.
You cannot upload attachments in this forum.
You cannot download attachments in this forum.
Users who participated in discussion: AROS-Confidence, terminills, Argo, Bohun, danilos, coffeecat