Amaan Cheval, Developer in Bengaluru, Karnataka, India
Amaan is available for hire
Hire Amaan

Amaan Cheval

Verified Expert  in Engineering

Software Developer

Bengaluru, Karnataka, India
Toptal Member Since
October 9, 2019

Amaan is an ardent advocate of open-source and is the maintainer for the x86-64 BSP for RTEMS, an open-source real-time operating system used in space missions, including on NASA's Parker Solar Probe. He has also worked on an Intel x86 emulator that runs in the browser, sped up by a custom-made JIT compiler. He loves challenging problems, ranging from kernels and compilers to distributed systems, cryptography, and reverse engineering.


RTEMS (Open-source Organization)
C++, Assembly, C, Embedded Systems, Kernel, Linux Kernel, Network Programming...
Droplet Computing
Rust, Quick EMUlator (QEMU), Networking, VPN, STUN/TURN, ICE, TCP/IP, UDP...
Toptal Client (under NDA)
C, Intel DPDK, Intel, Linux Kernel, LXC, Transmission Control Protocol (TCP)...




Preferred Environment

Git, Emacs, Linux

The most amazing...

...code I've written was to port a UEFI bootloader from FreeBSD's kernel, and adapt it to RTEMS so that RTEMS could load ELF kernels regardless of UEFI/BIOS.

Work Experience

Maintainer of x86-64 BSP

2018 - PRESENT
RTEMS (Open-source Organization)
  • Made upstream patches to GCC so it would correctly include C runtime files (i.e. the ones that call the "main" function) for RTEMS x86-64 target binaries, and would allow for custom GCC spec options (such as -qrtems, which link the standard RTEMS libraries into a program).
  • Evaluated how UEFI support functioned on various operating systems, including FreeBSD and Arch Linux, discussing the pros and cons of every approach with the open-source community, and finally porting FreeBSD's UEFI bootloader to RTEMS after unanimous agreement.
  • Developed code to calibrate Intel x86-64's dynamic APIC timer by using the PIT (which runs at a fixed frequency). Since RTEMS is an RTOS, timing is of critical importance, and this step determines how task-scheduling and context-switching are handled by the kernel.
  • Implemented all the code required by the RTEMS kernel to initialize contexts, and switch contexts (for pre-emptive context switching schemes), by perfectly storing and restoring all machine state (i.e. hardware registers, flags, etc.).
  • Built a system for the RTEMS kernel to be able to hook into the microprocessor's interrupts, and to correctly fire user-subscribed tasks upon said interrupts (for eg. in a space mission, it might be "calculate the recalibration needed by the thrusters every time the sensors detect movement" - the sensors may be attached to a hardware interrupt, which the kernel will handle, and schedule the user's task for).
  • Implemented a polling console driver to allow the RTEMS kernel to log messages to a console over UART.
  • Mentored students for Google's Code-In and Google's Summer of Code, helping them familiarize themselves with RTEMS, debug issues, and giving them feedback and guidance on their projects.
Technologies: C++, Assembly, C, Embedded Systems, Kernel, Linux Kernel, Network Programming, Hardware, Microcontrollers, Embedded Software, Embedded Hardware, Cryptography, Networking, Encryption, UEFI, Firmware, Documentation, Robotics, ASCII, UTF-8, Embedded C, Embedded C++, Real-time Operating System (RTOS), Device Drivers, Linux, Quick EMUlator (QEMU), Linux Kernel Modules, Embedded Linux

Software Developer

2023 - 2023
Droplet Computing
  • Developed a cross-platform networking back end in Rust for QEMU (similar to Slirp) that supports connecting VMs to each other seamlessly over an encrypted VPN tunnel as if they are connected on a LAN (i.e., peer A=, peer B=
  • Supported peer-to-peer IP packet transfer using WireGuard/BoringTun, regardless of peer's network conditions (i.e., NAT traversal for "home router"/ISPs with NAT, UDP hole punching, supporting endpoint-dependent mapping (EIM) as best as possible).
  • Provided support for firewall/rule-based user-mode networking for VMs to not only access peer VMs, but also the host's LAN, the internet, etc., by decapsulating/encapsulating TCP and UDP packets appropriately for the VM.
  • Included support for libvirt/virsh-based QEMU VMs by using a Python script that can dynamically edit a libvirt VM's config to use the Droplet networking back end instead of Slirp, etc.
Technologies: Rust, Quick EMUlator (QEMU), Networking, VPN, STUN/TURN, ICE, TCP/IP, UDP, WireGuard, BoringTun, Shell, Embedded Linux

Embedded Software Engineer

2021 - 2022
Toptal Client (under NDA)
  • Set up a dedicated 32x100G switch (Aurora Netberg 710), programmable with Intel P4 (a programmable ASIC network chip and BSP) to act as a SPAN with port mirroring (i.e., packet capture on configurable ports, mirrored to other ports at 100 Gbps).
  • Built a tool to detect dropped packets/gaps in PCAPs of financial market data, to be run as diagnostic software for stock exchanges/traders. The data is a proprietary networking protocol based on UDP.
  • Built a tool to track TCP sessions and calculate various RTTs (round-trip time), both to connect initially (SYN/ACK) and for every subsequent message (PSH/ACK) to be used in the financial market analysis systems to track down latency issues.
  • Prototyped Intel DPDK with DPDK-compatible applications (such as Suricata IDS/IPS) to ensure higher throughput rates without needing to process packets in kernel space (DPDK speeds network processing up by being primarily a user-space runtime).
  • Maintained a 100 Gbps packet capture system, including configuring TinyCore OS, setting up Lua scripts, debugging Linux kernel modules, etc.
  • Prototyped an Intel DPDK replacement for an eBPF/XDP-based program which performed load-balancing/pre-filtering on all traffic on a Linux host.
Technologies: C, Intel DPDK, Intel, Linux Kernel, LXC, Transmission Control Protocol (TCP), Assembler x86, eBPF, Arduino IDE, Hardware, Microcontrollers, Embedded Software, Embedded Hardware, Cryptography, Networking, Yocto, Kernel, Firmware, Raspberry Pi, Embedded C, Embedded C++, Device Drivers, Linux, Debian Linux, Linux Kernel Modules, Kernel Programming, KVM, Embedded Linux, Linux Device Driver

Full-stack Developer and DevOps

2020 - 2020
Toptal Client (under NDA)
  • Created a Node.js back-end server, with a Next.js component and a custom Express.js component, built as a real-time distributed entity-store for various data pipelining applications.
  • Built Chrome extensions to (1) monitor RAM+CPU usage on PC and automatically suspend tabs and (2) capture historical archives, notes, pages screenshots in various modes (such as automatic back-up of all visited pages vs. only highlights, and more.).
  • Built front-end components in React, including React Hooks that simplified certain aspects of our system common to all "entities" in the entity store: type-checking, permission-handling, undo/redo, and more.
  • Set up an on-prem deployment of a Minikube pod with Docker containers such that the AWS Cloud and on-prem versions of the infrastructure were compatible while still accounting for various specifics such as DNS hostnames, TLS certificates, and more.
  • Built an Electron wrapper around a web front-end to use native features such as accessing the filesystem.
  • Architected various propositions for scalable, real-time, versioned, and permissioned data-stores, including technologies such as Kafka, Redis, Kubernetes, Nginx, and down to application-specific back-ends in Node.js.
Technologies: Amazon Web Services (AWS), Amazon EC2, SSH, Docker, Kubernetes, Electron, Chrome Extensions, PostgreSQL, TypeScript, GraphQL, React, Node.js, JavaScript, Cryptography, Encryption

Embedded Engineer

2019 - 2020
  • Wrote and customized Linux kernel drivers for a new touchscreen (including both input and display drivers), such that it's fully functional with Android (brightness, orientation, resolution, etc.).
  • Added support for Android applications to access hardware serial ports through SELinux restrictions.
  • Helped hardware teams determine smart battery packs, controller ICs, and charging circuits required for battery functionality in Android device, based on existing Linux drivers and functionality requirements.
Technologies: Embedded C, C++, Kernel, C, SELinux, AOSP, Android, Linux, Embedded Systems, Linux Kernel, Arduino IDE, Hardware, Microcontrollers, Embedded Software, Embedded Hardware, Networking, Firmware, RFID, Robotics, Embedded C++, Device Drivers, Linux Kernel Modules, Kernel Programming, Embedded Linux, Linux Device Driver

Systems Programmer

2017 - 2019
Droplet Computing
  • Helped develop an Intel x86 emulator which runs in browsers or Node.js environments by compiling source code to WebAssembly, in a small team where every member was always responsible for many components.
  • Created a method of automatically generating randomized, deterministic tests for most machine instructions supported by the emulator. Test fixtures were generated by running the tests on an oracle (such as QEMU or GDB for Intel x86 hosts), and then compared with the actual results of running through our emulator, in real-mode.
  • Sped up the generation of test fixtures from taking 3 mins, down to a solid 15 seconds, for hundreds of automatic tests, by parallelizing the process and reducing state setup and teardown.
  • Implemented various techniques of detecting hot-code basic blocks in the guest OS and compiling them Just-In-Time to WebAssembly, thereby allowing the emulator to be sped up by directly executing the guest OS's instructions, without having to read from emulated memory and having to reinterpret instructions, supporting a dynamic system for invalidating cached blocks efficiently as well.
  • Helped build the networking stack bridge required between guest-to-host interactions, to allow the guest's networking events, such as sending physical Ethernet frames, to be correctly unwrapped into TCP/UDP packets the host OS could actually send/receive, and then repackaging the host's network response into a physical frame for the guest OS.
  • Built a custom instrumentation profiler for the emulator, to be able to dynamically examine and find bottlenecks in the application.
  • Implemented most of the emulation code for a hardware Floating Point Unit (FPU), MMX, and SSE instructions, enabling more modern applications such as Microsoft Word and Wine to function correctly in the emulator.
  • Experimented with methods of symbolic execution using KLEE to automatically increase code coverage across the project. Measuring code coverage also required extending LLVM intrinsics due to our compiler-chain targeting WebAssembly.
Technologies: Flask, Python, Docker, OCaml, JavaScript, Assembly, WebAssembly, C, Rust, Embedded Systems, Kernel, Linux Kernel, Network Programming, Hardware, Microcontrollers, Embedded Software, Embedded Hardware, Cryptography, Networking, Encryption, Yocto, UEFI, Firmware, ASCII, UTF-8, Embedded C, Embedded C++, Device Drivers, Linux, libvirt, Quick EMUlator (QEMU), Debian Linux, Linux Kernel Modules, Kernel Programming, Embedded Linux, Linux Device Driver

Developer Success Engineer

2016 - 2017
  • Developed a custom application that would act as a SAML Identity Provider for any client, and would allow sending back intentionally malformed SAML Responses. This application proved very useful when debugging issues customers had in integrating their systems with Auth0's SAML systems.
  • Provided support to customers using a variety of technologies, regardless of familiarity with said technologies, by asking relevant questions and knowing how to gather the relevant HTTP requests in different environments (i.e. capturing HAR files and analyzing those).
  • Guided customers as an expert on various authorization protocols, including OAuth, OpenID Connect, SAML, and WS-Fed, and help customers architect their applications securely.
  • Created both internal and external documentation on specific technical topics related to authorization, thereby reducing my own bus factor.
  • Volunteered as a "concierge" to answer any questions the rest of the company had about the authorization pipeline, its features, its security guarantees, recommended methods of use, etc. This allowed engineering teams to focus more on creating features instead of explaining them.
Technologies: Go, Python, JavaScript, Cryptography

HTML5 Game Developer

2010 - 2011
  • Ported various Flash / ActionScript based games to HTML5 so they would work in web browsers on mobile devices too.
  • Developed several 2D platformer games, puzzle games, and action games for various online gaming portals.
  • Created a custom game framework for common elements of game development such as sprite management, media management, UI and screen elements, pub/sub event management, etc.
Technologies: SVG, CSS3, HTML5, Canvas, JavaScript

Phone to Chrome

Phone to Chrome is an Android app and Chrome extension that users can install to easily share links from their mobile devices to Chrome, having them magically opening on their desktops.

The app has over 50,000 downloads and has been very well-received in general.

Music Recommender System
A proof-of-concept application written in Python that uses cosine similarity on LastFM's vast database of user preferences in music to recommend bands to new users based on their tastes.

Pizza Delivery Bot

We used an ATMEGA 2560 microcontroller to build a "pizza delivery" bot. The pizzas were colored thermocol boxes of different sizes, and the bot had to recognize them, pick them up, and deliver them to houses marked out on a flex sheet in optimal time.

I led the team and wrote most of the code that ran on the microcontroller while other team members assembled the bot's hardware.
2014 - 2018

Bachelor's Degree in Computer Science

Mumbai University - Mumbai, India


Node.js, React, libvirt


Emacs, VirtualBox, VMware, NGINX, GNU Debugger (GDB), Kibana, Git, Canvas, Mocha, Intel DPDK, VPN, WireGuard, Shell


C++, Embedded C++, Rust, C, JavaScript, Python, Assembly, Embedded C, NASM, OCaml, Go, HTML5, CSS3, GraphQL, TypeScript, Lisp, Agda, R, Assembler x86


Kernel, Linux, Arch Linux, Embedded Linux, AVR, Quick EMUlator (QEMU), Raspberry Pi, Debian Linux, Kernel Programming, Kubernetes, Amazon EC2, Amazon Web Services (AWS), Android, Docker, Arduino, Intel, KVM


PostgreSQL, MongoDB


Continuous Integration (CI), Continuous Deployment, Agile, Functional Programming, DevOps


Flask, Express.js, Electron, Svelte


Embedded Systems, Chrome Extensions, WebAssembly, Linux Kernel, Network Programming, Firmware, Arduino IDE, Hardware, Microcontrollers, Embedded Software, Embedded Hardware, Cryptography, Networking, Encryption, Robotics, Device Drivers, Cordova, Reverse Engineering, LLVM, QNX, Yocto, UEFI, RFID, ASCII, UTF-8, Real-time Operating System (RTOS), Linux Kernel Modules, Linux Device Driver, SVG, AOSP, SELinux, WebSockets, SSH, ARM Embedded, LXC, Transmission Control Protocol (TCP), eBPF, Documentation, STUN/TURN, ICE, TCP/IP, UDP, BoringTun

Collaboration That Works

How to Work with Toptal

Toptal matches you directly with global industry experts from our network in hours—not weeks or months.


Share your needs

Discuss your requirements and refine your scope in a call with a Toptal domain expert.

Choose your talent

Get a short list of expertly matched talent within 24 hours to review, interview, and choose from.

Start your risk-free talent trial

Work with your chosen talent on a trial basis for up to two weeks. Pay only if you decide to hire them.

Top talent is in high demand.

Start hiring