top of page
  • Aslan Autonomy

Project ASLAN - Low speed autonomy for engineers, by engineers.

By Efimia Panagiotaki - Lead Self-Driving Software Engineer, StreetDrone

Developing software for autonomous vehicles is resource intensive, time consuming and requires specialist skills. Organisations across the world are spending millions (or billions - see Amazon’s purchase of Zoox) attempting to build teams to develop full stack solutions, all aiming to deliver the promise of a driverless future.

Project ASLAN aims to bring down the barriers to entry, and drive forwards the readiness of low speed, urban autonomous vehicles. With an open-source core ensuring that all development costs are minimised, the benefits for the organisations involved are clear. However, how do those on the frontline stand to benefit? What sets ASLAN apart from the other open-source efforts on the market? Read on to discover ASLAN’s uniqueness for the user/developer, and how being a member could help accelerate your self driving research.

What makes the ASLAN platform great?

Aslan is a software stack developed to ensure systems reliability and overall hardware and software redundancy. The main focus of the project is to build a lean software stack with features that are working in parallel, validating each other and verifying each decision. Aslan has been built by professional software and automotive engineers who are aiming to allow all future collaborators to not only get started quickly but also start building functionality that is truly valuable to their specific use case. Built-in Robot Operating System (ROS), ASLAN leverages a framework that thousands of developers have used to successfully demonstrate robotics capability. However, it’s not just ROS that makes ASLAN great:

1. Deployment Support - key tools before you get started

The main thing that characterizes Project Aslan is the deployment support, with a range of features and tools to ensure that your low-speed autonomous vehicle development is up and running fast and efficiently.

A few of these features are listed below:

  • Comprehensive documentation, both in the source code and in the GUI with pop-up info boxes on each software package. At the packages with configurable parameters, we explain in detail what each parameter does and how it affects the source code.

  • Video tutorials: Installation and how-to-use quick start tutorials

  • Plug and play deployment via the Graphical User Interface (GUI)

  • Built-in ROS-based visualization tools (rviz and rqt)

  • ROS-based data manipulation tools (rqt and rosbag)

  • Simulation model and point cloud world

  • Teleoperation controls: joystick and keyboard

  • Quick Start Resources (default point cloud maps, waypoints and rosbags)

  • Source code and Docker

2. Installation - Up and running in minutes

It takes under 30 minutes to build our ASLAN software on a clean version of Ubuntu 16.04 installation. All that’s needed is our YouTube tutorial, a computer to specification, and the instructions on GitHub. With ASLAN, there is no frustration in failed installations, just follow the steps to ensure a successful pain-free install (feedback always welcome - let us know if it’s not this easy on our GitHub Issues Tracker!).

Alternatively, you can just pull the Project Aslan docker container from Dockerhub and get up and running in minutes, just by using the provided script and following the instructions.

3. Usability - Click and go

The ASLAN self-driving software pipeline is as close to plug and play as a self-driving stack can be, whether or not you have access to a compatible self-driving vehicle (see StreetDrone). After clicking a few buttons on a GUI (Graphical User Interface), you can initiate an end-to-end self-driving software stack. If you don’t have a car available you can use integrated simulation featuring the digital twin of an autonomous Renault Twizy (provided by StreetDrone, one of the founding partners). Our software pipeline has been designed to be easy to use and easy to understand so that you can get started as soon as possible.

4. Software Architecture - aiming for systems redundancy

Many large successful, open-source projects evolve to become broad-based in their approach to solving industry challenges, with numerous extensive feature sets and suitably complex algorithms. In these cases, the developer is tasked with debugging a very large general code base rather focusing on their own specific use cases.

Project Aslan’s main characteristic is that everything is working together and in parallel. We focused on keeping the codebase as lean as possible, without overly-complex features and software integrations that may slow down the developer, or slow down our ability to safely put vehicles on the road. The target architecture of the project is to have multiple implementations for each module, all verifying and validating each other’s output. For example, on this release of Project Aslan, the object detection module is performed by both lidar detection and radar detection, with both pipelines working in parallel and verifying each other’s output.

The sequence of message passing and parsing is well-defined, facilitating the addition of new features while keeping the global/unified messaging specified for the communication of each module. The goal of this software architecture is to ensure maximum reliability and overall redundancy.

5. Development Practices - clear and understandable code

The Project Aslan software stack is developed for software engineers by software engineers. Our objectives and core values during initial developments have been set with industrial requirements in mind, whilst building and testing the software, we have focused on ensuring that we have everything in place to accelerate the progress of users; from documentation, configuration, algorithms to software architecture, all have been built with the future developer at front of mind. Having understood the frustrations around code quality of open-source projects, we have ensured that the initial release is of the highest possible quality.

6. Correlation with reality - relevant to the real world

We have defined the default configurable parameters within ASLAN after real-world testing on real-world vehicles. The user can tune and configure specific parameters depending on the hardware they use, without affecting the rest of the software. We have spent a considerable amount of time improving our vehicle’s digital twin and the vehicle interface provided within ASLAN is tuned and configured after testing on a real car. All of this ensures that any simulated work within ASLAN remains relevant and transferable to real-world testing.

7. Scalability - ensuring our software can go places

Our software is fully modular, based on the ROS (Robot Operating System) middleware, enabling developers to add their own features on top. Each piece of code is well documented, facilitating the user to understand the messages that are being published, the software architecture of the stack and figure out ways to add features and improve the project.

For example: If a contributor would like to develop a vision-based path planning module, they should only make sure that the correct topics are being published in the way specified by the perception and path planning modules, in order to incorporate additional path planning features. In a similar way, if a contributor would like to add another vehicle in the software stack or another sensor, they only need to subscribe and publish the relevant ROS topics.

8. State-of-the-Art Algorithms - Deterministic software and robotics approach

Project Aslan uses state-of-the-art algorithms for localization (NDT), path planning (A* and pure pursuit), filtering (Voxel) and interfacing (SocketCAN). We have followed the “robotics approach” of top-down hierarchical design, including and developing only deterministic algorithms to ensure robustness and reliability throughout our codebase. Such an approach allows for the building of safety cases and robust testing and validation.

9. Software and drivers - we’ve anticipated the bugs!

The software and ROS drivers that Aslan code is dependent on have been tested and validated, before implementing into the stack. Common issues with these are either fixed or pointed out in the documentation to ensure that developers can enjoy making progress with minimal frustration.


We hope that all of these factors make Project ASLAN a pleasure to work with for its collaborators. However, we know that we can always do better - we welcome new collaborators to join us, contribute code and help get the world to the benefits of open-source, low-speed urban autonomy faster.

If you think you can help, and would like to get involved as an individual, technical or strategic partner, please contact

393 views0 comments

Recent Posts

See All
bottom of page