Introduction to JARU IDE
What is JARU IDE?
JARU IDE is the official integrated development environment for the JARU programming language. It was born with a clear objective: eliminating the barriers between idea and device. When you work with embedded systems, every minute counts, and JARU IDE is designed so you can focus on what really matters: creating solutions that work in the real world.
The IDE provides a complete workflow for writing, debugging, and deploying JARU code on ESP32 devices, with SiFive (RISC-V architecture) support in development. It also includes a Windows virtual machine that lets you develop and test your code without needing physical hardware connected—especially useful during early development phases or when working away from the lab.
An Editor Built for JARU
The heart of any IDE is its code editor, and JARU IDE's editor has been built from scratch with the language's particularities in mind. Syntax highlighting isn't generic: it recognizes JARU-specific constructs and presents them clearly and consistently.
Intelligent autocompletion goes beyond suggesting keywords. It analyzes your code's context to offer functions and variables that make sense at each moment. When you're working with sensor drivers or configuring peripherals, the IDE suggests exactly what you need without having to search through documentation.
A particularly useful feature is synchronized identifier editing. By activating it with Ctrl+J, you can rename a variable across all its occurrences simultaneously, avoiding the typical errors of manual search and replace. The integrated code formatter keeps your style consistent with a single click, and the symbol navigator lets you jump between functions and classes without losing track of what you were doing.
Errors and warnings appear marked directly in the editor margin as you type, allowing you to fix problems before attempting to compile.
Debugging Without Complications
Debugging embedded code has traditionally been a frustrating process requiring external tools and complex configurations. JARU IDE proposes a different approach: develop and debug on the Windows VM, deploy to ESP32 when it's ready.
The integrated Windows virtual machine allows you to test and debug your code without needing the hardware connected. You can set breakpoints by clicking on the editor margin. When execution stops, you have full control: advance line by line with Step Over, enter called functions with Step Into, or exit the current function with Step Out. The Watch window shows you the value of the variables you're interested in real-time, updating with each execution step.
This ability to see exactly what's happening inside your program transforms the development experience: bugs that previously required hours of print statements and trial and error are now identified in minutes. Once your code works correctly on the VM, you can deploy it to your ESP32 with confidence that the logic has been tested.
- Develop and debug on the Windows VM with breakpoints and watch
- Test the logic of your program without depending on hardware
- Deploy to ESP32 when the code is ready and verified
GPIO Simulator for Windows
When developing code that interacts with hardware, the Windows VM wouldn't be complete without a way to test GPIO pin behaviour as well. The JARU GPIO Simulator covers exactly that need: a standalone window that connects to the VM via shared memory and reflects the state of every pin your program is using in real time, at a refresh rate of ~30 fps.
Pin table
The left half of the simulator shows a table listing every pin registered by your program. Each row reflects the current state of a pin and includes the following columns:
| Column | Description |
|---|---|
| GPIO | Pin number |
| Direction | Input / Output |
| Type | Digital, ADC, DAC or I2C |
| Pull | None, Pull-Up or Pull-Down |
| State / Value | Digital level (HIGH/LOW) or analogue value (0–4095) |
| Connected To | Virtual device associated with the pin |
You can add pins manually with the New GPIO button or remove them with Delete GPIO, and the configuration is saved automatically between sessions.
Device cards
The right half displays the device cards: virtual components you can attach to any pin to simulate real hardware behaviour. Each card is linked to a specific pin and updates in sync with the VM.
| Device | Type | Description |
|---|---|---|
| Red / Green / Blue LED | Output | Visual indicator that reflects the digital state or PWM intensity of the pin |
| Push Button | Input | Momentary button that injects a HIGH level while held down |
| Switch | Input | Toggle that alternates between HIGH and LOW on each click |
| Potentiometer | ADC Input | Knob that generates analogue values from 0 to 4095 |
| Temperature Sensor | ADC Input | Simulates readings from a temperature sensor with an adjustable value |
| Phototransistor | ADC Input | Simulates ambient light variations via a slider control |
| Oscilloscope | Monitoring | Displays the PWM waveform of the signal in real time |
| Signal Generator | ADC Input | Plays back value sequences from a CSV file or generates automatic patterns |
| WS2812 Strip | Output | Displays a NeoPixel LED strip or matrix in real time with configurable layout (Strip, 8×8, 16×16, 32×8, 8×32, 4×4) and wiring mode (Sequential, Serpentine H, Serpentine V) |
Signal generator
The signal generator deserves a special mention. It allows you to feed an ADC pin with predefined data to reproduce complex test scenarios without any physical hardware. You can configure the generation mode (manual, automatic or CSV), the minimum and maximum signal bounds, the interval between samples, and whether the sequence should loop. By loading a CSV file you can replay data captured from a real sensor, which is particularly useful for validating signal-processing algorithms.
Launch the simulator before running your program in the VM. Add the pins you want to monitor manually using the New GPIO button — once your program calls GPIO.pinmode(), the pin's configuration (direction, type and pull mode) will be reflected automatically in the table. You can then attach a device card to each pin to interact with it without any physical hardware.
WS2812 strip
The WS2812 card lets you visualize in real time the state of a NeoPixel LED strip or matrix controlled by your program. The display synchronizes with the VM through the shared memory area and only repaints when the VM marks new data, keeping performance smooth even with long strips.
You can choose the layout from the card's dropdown: linear strip mode or various matrix configurations (4×4, 8×8, 16×16, 32×8, and 8×32). The wiring mode determines how pixels are mapped onto the grid: Sequential for strips where all LEDs run in a single direction, Serpentine H and Serpentine V for matrices where each row alternates reading direction horizontally or vertically, respectively.
The status label at the bottom of the card always shows the number of active LEDs, the current layout, and the brightness level reported by the VM.
Integrated Project Management
JARU IDE understands that a project is more than a collection of code files. The project wizard guides you step by step in creating new projects, automatically setting up the folder structure, main file, and necessary metadata. If you prefer learning by example, the IDE includes demo projects you can explore and modify.
The file explorer presents your project in a familiar tree view, where you can create, rename, and organize files and folders with drag and drop operations. Recent projects appear on the start screen so you can resume your work with a single click. The IDE also automatically generates README and license files if you need them.
Version Control Without Leaving the IDE
Git workflow is integrated directly into JARU IDE. You can see the status of your files (what you've modified, what's new, what you've deleted), make commits, manage branches, and check history—all without opening a terminal or switching applications.
The diff viewer shows you exactly what has changed between versions, making it easy to review code before committing changes. This integration is especially valuable in collaborative projects or when you need to revert to a previous version of your code.
Visual Tools for Multimedia Resources
Modern embedded development frequently involves graphical interfaces, and JARU IDE includes specialized editors for the visual resources that applications need.
The image editor lets you load, crop, and adjust images, but its real utility lies in palette conversion. You can reduce an image to 256 colors or apply a unified palette, optimizing the result for embedded device memory limitations. Export generates formats directly usable by the hardware.
For animations, the sprite editor offers frame-by-frame creation with precise timing control. You can configure FPS, adjust each frame's alignment, and preview the result in real time before exporting. This eliminates the cycle of export, test on device, adjust, and repeat.
Everything You Need for ESP32
Working with ESP32 microcontrollers requires configuring multiple hardware aspects, and JARU IDE centralizes all these tasks in a coherent interface.
Firmware flashing supports different flash memory modes (DIO, QIO, DOUT) according to your board's characteristics. WiFi configuration lets you set SSID, password, IP addressing (static or dynamic), and DNS servers without manually editing configuration files.
For IoT projects, MQTT configuration is equally integrated: broker, port, credentials, QoS levels, and will messages are configured from the IDE. The same applies to TFT displays, where you can specify SPI pins, resolution, and controller; and to SD cards, with their corresponding pin configuration.
The integrated serial monitor lets you communicate with the device by selecting the port and baud rate from the IDE. The SPIFFS file system is accessible for persistent storage, and you can query chip information like MAC address or device identifier directly from the IDE's tools.
I2C Driver Library
One of the most repetitive tasks in embedded development is writing initialization code for sensors and actuators. JARU IDE includes an I2C driver manager with a category-organized library that greatly simplifies this process.
Each driver in the catalog shows detailed information: the chip it supports, its I2C address, author, and version. Before inserting code into your project, you can preview it to make sure it's what you need. When inserting, the IDE automatically generates initialization code configured with the SDA/SCL pins and I2C port you've specified.
Output Console
The output console is your window into what's happening during compilation and execution. Compiler messages appear with errors and warnings clearly differentiated. The serial monitor shows device communication in real time. Message type filters help you find what's relevant when there's a lot of information, and a clear button lets you start with an empty console when needed.
Supported Platforms
JARU IDE lets you run your code in different environments depending on your development phase:
| Platform | Description | Status |
|---|---|---|
| Windows VM | Integrated virtual machine for development and testing without hardware | Available |
| ESP32 | Espressif microcontroller for deployment on real devices | Available |
| SiFive | RISC-V architecture for projects with specific requirements | Coming soon |
System Requirements
JARU IDE is designed to run on modest hardware, though more powerful equipment will improve the experience especially on large projects:
| Component | Minimum Requirement | Recommended |
|---|---|---|
| Operating system | Windows 10 | Windows 10/11 |
| RAM | 4 GB | 8 GB |
| Disk space | 200 MB | 500 MB |
| USB port | — | For ESP32 connection |
Getting Started
If you're not yet familiar with the JARU language, we recommend starting with the Language Guide before diving into the IDE.
JARU IDE includes a modern dark theme designed to reduce eye strain during long coding sessions.