Everything you need to build on ESP32 — in one cloud
Go from a blank ESP32 to a device that streams to your phone in one sitting — plain-language scripts instead of C, no toolchain, no server of your own, no rebuilds. Quick enough to test an idea, simple enough for a first lesson.
First flash from the browser over USB. After that, everything is over the air.
One ecosystem, four tools, zero glue code
R1BBIT turns an ESP32 board into a finished connected device — with no toolchain, no server of your own and not a line of C.
Three kinds of work suit it especially well: getting a product to its first working version fast, testing whether an idea holds up before you commit to building it properly, and learning electronics and robotics — that last one above all if you are starting from scratch.
The boards in our catalog are hardware we have verified by hand, but the ecosystem runs on almost any ESP32.
Firmware + R1BBIT-BASIC
The firmware carries an interpreter, so the board runs a plain text file instead of a compiled binary. Its 298 commands cover pins, sensors, displays, sound, camera and networking — no C, no toolchain, no compiling.
Web IDE
Write in the browser with autocomplete for every command and a checker that catches mistakes as you type. An assistant can write or fix the script for you, and a gallery of ready examples saves you the blank page. Even the very first flashing happens here, over a USB cable.
R1BBIT Cloud
Boards connect to it on their own over an encrypted channel. Readings are kept and drawn as charts, new scripts and firmware arrive over the air, and every device has a console and a file browser you can open from anywhere.
iOS & Android apps
A value the board publishes becomes a tile on your phone; move a slider there and the board reacts. The app also carries the editor, the console, the documentation and the same assistant — and it can ring you when something goes wrong.
CONFIG
PSRAM_SIZE 8
PSRAM_TYPE OCTAL
I2C_SDA 16
I2C_SCL 15
SPI_MOSI 11
SPI_MISO 13
SPI_CLK 12
DISPLAY_DRIVER ILI9341
DISPLAY_CS 10
DISPLAY_DC 46
DISPLAY_BL 45
DISPLAY_WIDTH 320
DISPLAY_HEIGHT 240
TOUCH_DRIVER FT6x36
TOUCH_INT 17
END_CONFIG
DISPLAY_INIT
DISPLAY_WIDGET(1, "label", 20, 24, 280, 36)
DISPLAY_WIDGET(2, "arc", 90, 76, 140, 140)
VAR T, F
VAR A[1]
DS1820_INIT(A, 1000)
VARS_PUBLISH(T, F)
WHILE(1)
T = A[0]
F = T * 9 / 5 + 32 ' to Fahrenheit
UI_TEXT(1, "Temperature " + T + " C")
UI_VALUE(2, T)
IF T > 30 THEN SEND_NOTIFY("Greenhouse", "Too hot: " + T)
PAUSE 1000
WEND
Hardware and logic live in the same script
- CONFIG names the wiringDisplay driver, pins, buses, codec, camera, SD card — 184 directives, one syntax. The block is read before the script starts, so the hardware is ready by the first line of logic.
- Swap hardware in two linesReplace an ILI9341 with an ST7789: change the driver and the size, keep the rest of the script. Moving a sensor to other pins is one number.
- A mistake never bricks the boardA wrong CONFIG stops the script from starting with a clear message. The firmware and the cloud link stay up, so the fix goes out over the air.
- The dashboard comes freeVARS_PUBLISH makes a variable visible in the cloud and on the phone. No API to write, no endpoint to register — the value is simply there.
Flash once
The web flasher writes the firmware from the browser over USB. No toolchain, no drivers to hunt down, no IDE to install.
Write
In the web IDE or the mobile app — with autocomplete, inline parameter hints and a linter that catches mistakes before the board sees them.
Send to the board
Press Run and the script is on the board in seconds — over the air, over an encrypted link. From an SD card or on boot, if you prefer.
Watch it run
Now you can see it working: readings reach the dashboard and your phone about once a second, and the console answers from wherever the board is.
Built for the part of the job that usually hurts
If you came to ESP32 through the Arduino IDE, you know the price of every change: recompile, plug in the cable, reflash, repeat until the logic settles. Blynk and Arduino Cloud hand you a dashboard and a cloud, but the logic underneath is still C++ that has to be rebuilt and uploaded again for every edit. R1BBIT keeps the control and drops the rebuild: the logic is a text script the board reads, and the dashboard is simply the variables it publishes.
Change the logic, not the firmware
Your program is a text file the board reads and runs. Edit a line in the browser, send it to the board, and it takes effect — the firmware itself never changes. Even the wiring is described in text: switching displays or moving a sensor to other pins is an edit, not a new build.
- First flash from the browser over USB — no toolchain, no IDE to install
- Scripts run in an isolated interpreter: a bug stops the script, the board stays online
- Firmware updates arrive over the air, encrypted with AES-256-GCM
With the Arduino IDE every change is a compile-and-reflash cycle over a cable.
The cloud is already running
There is nothing to install or host. Devices connect to cloud.r1bbit.com out of the box, telemetry lands in a time-series database and charts itself, and every device gets a remote terminal and file manager. Need data from the internet? HTTP_GET fetches it straight from the board — no middleman.
- Readings go up once a second over an encrypted channel and are kept for you
- A console, a file browser and firmware updates for every board you own
- The board can fetch data from any web API by itself — nothing to host in between
With Blynk or Arduino Cloud the dashboard is ready, but the sketch behind it is still C++ you rebuild and upload for every change.
An assistant that knows the language
Describe what the device should do and the built-in assistant writes R1BBIT-BASIC for it. It sees the script you already have, so it can extend it, explain a command or hunt down the error you cannot find. It lives in the web IDE and in the mobile app alike.
- Write from a description, change an existing script, fix errors, explain the language
- Answers are checked against the real command reference before they reach you
- Invented constructs are flagged instead of quietly handed over as working code
A general-purpose chatbot happily invents commands this language has never had.
On the screen and in your pocket
27 widget types render on the device’s own display — charts, gauges, sliders, even OpenStreetMap tiles. Publish a variable and it becomes a widget in the mobile app; move a slider there and ON_VAR fires on the board. A push notification is one command.
- 27 kinds of on-screen element, from a label to a chart or a gauge
- iOS and Android apps — tiles bound to the values your board publishes
- One command sends a push notification, even with the app closed
In practice it is one step: add a widget in the mobile app and point it at a variable — the device subscribes to it automatically and starts sending the data.
Safe to experiment
The interpreter is isolated from the firmware. A runtime error stops the script; the board keeps its connection and takes the fix over the air.
Multitasking in the language
Up to 15 background tasks plus the main loop, with shared variables and a cooperative scheduler — no RTOS code.
Cellular fallback
Add a SIM module and the board keeps telemetry, terminal and script delivery alive when Wi-Fi drops.
Audio, camera, video rooms
Play MP3 and tracker music, record, run an FFT, stream a camera to a browser or to another board.
The whole project lives in one tab
Embedded work is rarely just code. There are files to get onto the board, images the display can actually read, fonts that have to fit in flash — and a lot that is better off never landing on the board at all. All of it sits in the same browser tab as the editor: no separate utilities, no SD-card shuffling.
The board’s files, from wherever you are
Open the device files dialog and you are looking at the flash of a board that may be in another building. Browse it, drop a file into the window to upload, pull one back down, rename, delete, make folders — and save the script you are editing straight onto the device. The free-space meter shows what is left before you push a big font or a sound.
- Internal flash and an SD card in the same dialog
- Drag a file into the window to upload; download or delete any file back
- Save the open script to the board without leaving the editor
- It all rides the cloud connection — no cable, no card reader
Pictures and sound the board never has to store
A board has under a megabyte of flash — a single photo can eat half of it. So keep the media in the cloud instead: upload a file once, give it a short name, and write that name with an @ in front of it. The board fetches it when the script asks for it, at the size the script asks for, and stores nothing.
- Show a picture: DISPLAY_WIDGET(1, "image", 0, 0, 320, 240, "@logo")
- Swap it for the next frame with UI_IMAGE(1, "@frame2") — animation without touching flash
- Play sound or a radio stream with PLAY_AUDIO("@intro"), video with VIDEO_PLAY("@clip")
- Change the picture on the server and every board shows the new one — nothing to reflash
Not a menu of names — working editors
Draw it, then turn it into code
Open a picture, crop it, paint over it, pick the colour depth the display wants — and take the result out either as an array pasted into your script or as a file sent straight to the board. The counter at the bottom tells you what it will cost in bytes before you commit.
Keep the letters you need
Load any TTF, choose which character ranges to keep, and fix an awkward glyph by hand pixel by pixel. The line at the bottom counts the memory it will take — and warns when most of it is empty space, which is the usual reason a font does not fit.
Lay the screen out by hand
Set the canvas to the size of your display, then drag on labels, buttons, sliders, gauges, charts and lists and arrange them on a grid. Press one button and you get the script that draws exactly that screen — and it reads an existing script back, so a layout can be reworked later.
Chiptune, note by note
Tracker modules play in the browser and on the board alike. Open one and you get the pattern grid with every note and effect, the channel list and all the samples — edit it here and the same file plays from your script.
Frame by frame, down to one bit
A clip becomes a strip of frames you can edit individually — draw on one, duplicate it, cut a range out. Then squeeze it down to what a small screen can take: one-bit black and white with a dither, or compressed colour.
Trim it, shrink it, play it
Drop in a track and you see the waveform: select a piece, cut it, keep only what you need. Then pick the bitrate, and the line underneath tells you the price in advance — a two-and-a-half minute track went from 15 MB down to 1.3, small enough to keep on the board.
Whatever you make here goes straight to the board — or stays on the server, where a script reaches it by name.
The whole workshop in your pocket
The mobile app is not a remote control bolted on at the end — it is the same workflow as the browser. Build the dashboard, write and edit scripts, move files on and off the board, open a terminal, watch live values, read the docs and ask the assistant for help. Sign in and every device on your account is already there.
Editor
Widgets
TerminalMultimedia that fits in three lines
Audio and video on a microcontroller usually mean codecs, buffers and a week of reading datasheets. Here they are commands: play a station, join a voice room, start a camera. The firmware carries the decoders, the cloud carries the channel.
Play music and radio
Point the command at a file in flash, at a file you keep on the server, or straight at an internet radio station — the board decodes it and plays. It can also tell you what is playing right now, because it reads the station’s track info.
VAR title$
PLAY_AUDIO("https://mangoradio.stream.laut.fm/mangoradio")
WHILE 1
AUDIO_TITLE(title$)
PRINT "Now playing: " + title$
PAUSE 5000
WEND
A walkie-talkie between devices
Put several boards in the same room and they hear each other. Hold a button to talk, release to listen. Phones can join the same room, so a device and a person end up on one channel — useful for a workshop, a gate, a greenhouse at the far end of the plot.
CONFIG
IN1 4
IN1_PULL UP
END_CONFIG
JOIN_AUDIO_ROOM("myteam", 16)
WHILE 1
IF IN1 = 0 THEN PTT(1)
IF IN1 = 1 THEN PTT(0)
PAUSE 50
WEND
Camera to a phone — or to another board
Start a video room and the camera goes live. Watch it in the mobile app or in a browser, and a second board with a screen can join the same room as a viewer — a doorbell showing itself on the panel in the kitchen, with no server of your own in between.
CAM_INIT
CAM_RESOLUTION(320, 240)
START_VIDEO_ROOM("frontdoor", 10)
// on the board with the screen:
// JOIN_VIDEO_ROOM("frontdoor")
Voice and video ride a low-latency channel with an automatic fallback if it is blocked. Sound also gives you note and melody playback, tracker modules, WAV and MP3 recording and a live spectrum analyser.
All sound and video commandsAlmost any ESP32
The firmware builds for six targets — ESP32-S3, ESP32-P4, ESP32-C6, ESP32-C3, the classic ESP32 and the S3 without PSRAM. The boards below are the ones we have verified hands-on. Bring a dev board of the same family and it gets its own CONFIG block just the same.
ESP32-S3
9 boardsThe reference platform — new features land here first
- SPI displays and capacitive touch
- DVP camera, audio, FFT, tracker music
- HTTP feeds, cellular fallback
- No MIPI-DSI / CSI, no Ethernet
ESP32-P4
6 boardsThe big-screen one
- MIPI-DSI panels up to 1280 px, CSI cameras
- Ethernet, H.264 video viewer, OpenStreetMap
- 32 MB PSRAM — room for large UIs
- Wi-Fi goes through a C6 co-processor — light sleep drops the link
ESP32-C6
5 boardsWi-Fi 6 in a tiny footprint
- OLED / TFT displays, sensors, PWM, UART
- Audio playback and internet radio
- Deep sleep and wake on GPIO
- No HTTP feeds, no capacitive-touch pins
ESP32-C3
2 boardsThe smallest and cheapest
- OLED / TFT displays, sensors, PWM, UART
- Deep sleep and wake on GPIO
- Cloud telemetry and remote terminal
- No audio or FFT, no HTTP feeds, no touch pins
Also builds for the classic ESP32 (D0WD) and the ESP32-S3 without PSRAM — same language, smaller set of commands.
ELECROW ESP32-P4 Display 1024x600
View details
Waveshare ESP32-P4-NANO
View details
ESP32-S3 Touch Screen 240x320
View details
Waveshare ESP32-S3 240x240
View details
Waveshare ESP32-P4-WIFI6
View details
XIAO ESP32-C6
View details
ESP32-C6 Mini
View details
XIAO ESP32-C3
View detailsFrom one prototype to a product line
The ecosystem is ready for commercial work today. Build a device on an ESP32, and the same firmware, the same cloud and the same apps that run the first board on your desk will run a hundred of them in the field — nothing has to be rewritten the day a project stops being a hobby.
Hardware you can just buy
R1BBIT runs on standard ESP32 modules sold in quantity by ordinary distributors. Going from one unit to a thousand is a purchasing decision, not a redesign, and the same script runs on every one of them.
Fix a fleet, not a device
A corrected script or a new firmware build goes out over the air to every board at once. Nobody drives to a site with a laptop and a cable.
Telemetry already stored
Every device writes its readings to the cloud, kept per device and ready to chart months back. There is no backend to write and no database to run.
Your customers get the app
The iOS and Android apps are published and ready. A device belongs to its owner’s account, and its widgets show up there without anyone building a second app.
Each board has an owner
A device is bound to an account, and everything it exchanges with the cloud — telemetry, commands, scripts and firmware — travels over an encrypted link.
Or bring your own board
The catalog lists hardware we verified by hand, but the firmware builds for six ESP32 targets — so a board of your own design can join the same ecosystem.
Refrigeration and cold-store statistics, building heating and air conditioning, workshop and greenhouse monitoring, access control, information panels — the same stack covers all of it.
R1BBIT for businessA first board that works in one lesson
Most of a beginner’s first day with a microcontroller is spent on things that are not programming: installing an environment, hunting for drivers, picking a board in a menu, waiting for a build. R1BBIT removes that day. A browser, a cheap board and a USB cable — and the class is writing logic in the first half of the lesson, not the third.
Three steps: from a blinking LED to a chart on the phone
Make something happen
CONFIG
OUT1 2
END_CONFIG
WHILE 1
OUT1 1
PAUSE 500
OUT1 0
PAUSE 500
WEND
Read temperature and humidity
CONFIG
I2C_SCL 7
I2C_SDA 6
END_CONFIG
VAR T, H
SI7021_INIT(T, H, 2000)
WHILE 1
PRINT "temp " + T + " hum " + H
PAUSE 2000
WEND
Send a warning to your phone
CONFIG
I2C_SCL 7
I2C_SDA 6
END_CONFIG
VAR T, H
SI7021_INIT(T, H, 2000)
VARS_PUBLISH(T, H)
WHILE 1
IF T > 27 THEN
SEND_NOTIFY("Too warm", STR$(T) + " C")
ENDIF
PAUSE 60000
WEND
Every script here is the whole program — there is no hidden setup file and no project to configure.
Nothing to install
Everything happens in a browser — on a school computer with no admin rights, on a laptop, on a tablet. There is no environment to roll out across a lab and nothing to keep updated.
A language you can read
Commands say what they do: DHT_INIT, PRINT, PAUSE, IF … THEN. A student reads a line and understands it, instead of copying a template nobody has explained yet.
A mistake costs nothing
The script runs in an isolated interpreter. A wrong line stops the script and prints why; the board stays online and takes the next version straight away.
Hardware a school can afford
The smallest supported chips cost a few dollars, and one board with a sensor is already a working lesson. A class set does not need a budget request.
What a class actually needs
- A browser on any machine in the room
- An ESP32 board from a few dollars
- One USB cable for the very first flash
- An LED or a sensor to point it at
No admin rights, no licences, and no lab image for anyone to maintain.
Documentation comes in English, Russian, Spanish, French and German.
Choose a plan, or stay on Free
Free
Free
- 3 devices
- 3 days of history
- 100 notifications a month
- AI assistant
- Readings saved to the database at most every 60s
Starter
$6.99/ month
or $69.99 a year
- 5 devices
- 90 days of history
- 1,000 notifications a month
- AI assistant
- Readings saved to the database at most every 60s
Professional
$19.99/ month
or $199 a year
- 15 devices
- 365 days of history
- 5,000 notifications a month
- AI assistant
- Readings saved to the database at most every 20s
Prices are per account in US dollars and come straight from our billing system. Paying yearly costs less than twelve monthly charges. Free needs no card at all.
Ready to build?
Open the cloud, read the docs or ask the forum — the first board takes an evening, not a weekend.