Skip to content

Portfolio // online

Arun
Jyothish

Systems Engineer · Embedded · Linux · Edge AI

From silicon to the operator.

I design and build embedded and distributed systems — board bring-up, real-time firmware, embedded Linux, device networking and accelerated inference at the edge — and validate them on real hardware.

Photograph of Arun Jyothish
Systems · Engineer
Role
Software Design Engineer
Focus
Embedded systems
Base
Kochi · India
Platform
Linux
Code
GitHub
Writing
dev.to
// Think in systems. Build in layers.

01

Systems I have built.

Embedded, Linux, networking and edge-AI systems — described at the level of architecture and approach.

Selected engineering work is presented at a high level. Proprietary implementation details, source code, internal architecture and company-specific information are intentionally omitted. Work shown reflects engineering experience, not independently owned products.

S-01
  1. Thermal sensor
  2. Local processing
  3. Zone logic
  4. MQTT
  5. Monitoring

Embedded thermal monitoring system

Embedded · IoT · Edge sensing

Developed embedded software for a thermal sensing and occupancy-monitoring system, integrating sensing, local processing, connectivity, persistent configuration and remote monitoring.

Technologies

  • C/C++
  • ESP32-class MCU
  • Thermal sensing
  • MQTT
  • Wi-Fi
  • BLE
  • OTA
S-02
  1. Node A
  2. Node B
  3. Node C
  4. Node D
  5. Application

Multi-node communication

Networking · Distributed systems

Worked on communication architectures for systems involving multiple network nodes, telemetry transport and distributed device coordination.

Concepts

  • IP networking
  • Multi-node communication
  • Routing
  • Telemetry
  • Distributed architecture
  • Fault handling
S-03
  1. Hardware
  2. RTOS / HAL
  3. Config · Network · OTA
  4. Device services
  5. Application

Embedded device platform

Embedded · Firmware · IoT

Built embedded software infrastructure covering device configuration, provisioning, persistent storage, connectivity, monitoring and firmware updates.

Layers

  • Provisioning
  • Persistent config
  • Connectivity
  • Monitoring
  • OTA update
  • RTOS / HAL
S-04
  1. Docs
  2. Embed
  3. Index
  4. Retrieval
  5. Ollama · Qwen
  6. Emacs

// Nothing leaves the machine

Local AI over engineering documentation

Local LLM · Retrieval · Developer tooling

A local retrieval-augmented setup that makes a personal software and design documentation base queryable from the development environment — Qwen models served by Ollama on the host, reached through gptel inside Emacs, with retrieval over the notes supplying the context for each answer.

Components

  • Ollama
  • Qwen / Qwen Coder
  • Local inference
  • gptel in Emacs
  • RAG over docs
  • Embeddings + vector index
S-05
  1. Boot ROM
  2. SPL / U-Boot
  3. Kernel + DTB
  4. Rootfs

// ROM to userspace on a new board

SoM bring-up on custom hardware

Embedded Linux · Yocto · Board bring-up

Brought up an NXP i.MX8-class system-on-module on a custom carrier board — bootloader and kernel configuration, device-tree work to describe the board's peripherals, and a Yocto-based BSP producing the image, from boot ROM through to a running userspace.

Scope

  • i.MX8-class SoM
  • Yocto / OpenEmbedded
  • BSP layers + recipes
  • U-Boot
  • Linux kernel
  • Device tree
S-06
  1. Org source
  2. C4 blocks + prose
  3. Org export
  4. HTML · Reveal.js

// One source · two published forms

Architecture documentation system

Org-mode · PlantUML · C4 · Documentation tooling

A documentation system where architecture diagrams live in the same Org files as the prose explaining them — C4-PlantUML sources rendered on export, a custom stylesheet for HTML and Reveal.js for presentations. One source, two published outputs, and diagrams that cannot drift from the text.

Pipeline

  • Org-mode
  • PlantUML
  • C4-PlantUML
  • Automated export
  • Custom CSS
  • Reveal.js
S-07
  1. Video in
  2. Pre-process
  3. DPU
  4. Detections
  5. Application

// Inference in the programmable logic

DPU-accelerated person detection

FPGA SoC · AI acceleration · Computer vision

Person detection on the deep-learning processing unit of a Xilinx UltraScale+ platform — the video path into the accelerator, deploying the detection model onto it, and optimising that model for embedded inference.

Scope

  • Xilinx UltraScale+
  • DPU accelerator
  • Hardware-accelerated inference
  • Person detection
  • Model deployment
S-08
  1. Camera sensor
  2. CSI-2
  3. CSI receiver
  4. V4L2
  5. Vision

MIPI CSI-2 camera integration

Linux · V4L2 · Camera bring-up

Brought up camera sensors over MIPI CSI-2 on embedded SoCs — a V4L2 driver for the sensor, I²C register configuration, device-tree description of the CSI link, and end-to-end debugging of the video pipeline feeding vision processing.

Path

  • MIPI CSI-2
  • V4L2 driver
  • Sensor bring-up
  • I²C configuration
  • Device tree
  • Video pipeline debug
S-09
  1. Cortex-A9 PS
  2. FreeRTOS tasks · ISRs
  3. AXI
  4. Prog. logic

// Fabric interrupts return to the tasks

Zynq-7000 real-time firmware

Zynq-7000 · FreeRTOS · HW/SW integration

Real-time firmware on a Xilinx Zynq-7000, with FreeRTOS on the Cortex-A9 processing system driving peripherals in the programmable logic — task and interrupt architecture, synchronisation, and bring-up either side of that boundary.

Scope

  • Zynq-7000 SoC
  • ARM Cortex-A9
  • FreeRTOS
  • Programmable logic
  • Interrupt handling
  • Task synchronisation
S-10
  1. PIC32 MCU
  2. Drivers / ISRs
  3. FreeRTOS kernel
  4. Queues · timers
  5. Tasks

PIC32 real-time firmware

PIC32 · FreeRTOS · Embedded firmware

Embedded firmware on a Microchip PIC32 under FreeRTOS — a real-time task architecture with inter-task communication and synchronisation, interrupt handling, peripheral integration and hardware bring-up.

Layers

  • PIC32
  • FreeRTOS
  • Real-time tasks
  • Queues + semaphores
  • Interrupt handling
  • Peripheral integration
Public workCode, experiments and docs in the open.github/arun-jyothish

02

Systems thinking.

Two views I return to constantly: how data flows through a system, and how a system stacks from silicon to the person using it.

Data flowsensor → user

  1. Sensorsacquisition
  2. Edge processingfilter · fuse · decide
  3. Communicationtransport · protocol
  4. Distributed servicesstate · coordination
  5. Control / visualisationoperator surface

System layersbidirectional

  • L6UserThe operator surface: what a person needs to see, decide and override.
  • L5ApplicationMission logic, coordination and the services that hold shared state.
  • L4NetworkTransports, routing and what happens when delivery fails or a node disappears.
  • L3OSEmbedded Linux or an RTOS — scheduling, drivers and the boundary to user space.
  • L2FirmwareBring-up, interrupts, timing and the code closest to the silicon.
  • L1HardwareSensors, SoCs and carrier boards — where every design is finally proven.

How I build

  1. 01Problem
  2. 02Requirements
  3. 03Architecture
  4. 04Prototype
  5. 05Implement
  6. 06Integrate
  7. 07Test
  8. 08Validate
  • > Architecture before implementation.
  • > Prototype early.
  • > Validate on real systems.
  • > Understand the entire stack.

03

Systems stack.

Grouped by engineering domain rather than scored — each group notes where it connects.

Software

  • C
  • C++
  • Python
  • Bash

→ every layer below

Embedded

  • ESP32
  • Sensors
  • UART
  • SPI
  • I2C
  • MQTT
  • OTA
  • BLE

→ device · edge sensing

Robotics

  • ROS 2
  • SLAM
  • Sensor fusion

→ perception · control

Networking

  • TCP/IP
  • UDP
  • Mesh
  • Ad-hoc routing
  • Telemetry

→ multi-node systems

Linux

  • Arch Linux
  • GCC
  • GDB
  • Git
  • tmux
  • zsh
  • Emacs

→ development environment

Engineering

  • KiCad
  • PlantUML
  • C4
  • Architecture
  • Git / Gerrit

→ design · review · docs

arun@workstation Ready
OS
Arch Linux
WM
i3
Term
tmux + zsh
Editor
Emacs / Spacemacs
Build
GCC / CMake
Debug
GDB
VCS
Git / Gerrit
Design
KiCad / PlantUML

A keyboard-driven Linux environment — tiling windows, persistent terminal sessions, one editor for code and notes. The point isn't minimalism; it's removing the distance between a thought and a running test.

Open source · github/arun-jyothishStandby
—
Public repos
—
Stars
—
Languages

Repositories and languages load live from the public GitHub API — nothing is shown until they arrive.

Open GitHub profile

04

Systems engineer.

I build systems where software meets hardware — from the first boot of a new board to the services and interfaces that sit on top of it.

Most of my work sits on boundaries — between firmware and the operating system, between a device and the network it reports to, between a control algorithm and the machine it actually moves. Those boundaries are where designs are proven or quietly fail, so that is where I spend attention.

I work in a Linux environment end to end, read specifications before writing code, and prefer to validate on the real system rather than only in simulation.

  • Architecture
  • Embedded software
  • Hardware/software integration
  • Networking
  • Distributed systems
  • Robotics
  • Edge intelligence
  • Linux

Experience

  1. Software Design Engineer

    Employer details available on request · work described generically

    • System and software architecture for embedded and distributed products
    • Embedded firmware development and hardware bring-up
    • Network and telemetry communication between devices and services
    • Integration, debugging and validation on real hardware
    • Code review and version control workflows (Git / Gerrit)

Engineering log

  • [ Systems ]Understanding multi-node routingHow packets actually find their way between peers, and what breaks first when a node disappears.Draft
  • [ Embedded ]Building reliable device provisioningIdentity, persistent configuration and first-boot flows that survive the field.Draft
  • [ Linux ]Engineering a keyboard-driven development environmentWhy the terminal, the editor and the build system should feel like one tool.Draft
  • [ Networking ]Designing IP-based device communicationChoosing transports, framing telemetry and deciding what to do when delivery fails.Draft

// Posts publish on dev.to as they are written.

05

Establish connection.

Roles, collaborations or a technical question — I read every message myself.

secure-channelopens your mail client

$ ./establish_connection