EVIA Paradigma
EVIA Paradigma is visual programming for people who like to see what the machine gets. The diagram is the program; the language is a setting. Wire blocks on a canvas, run them, then choose what they become: C99 to C++20 built with Clang or GCC, a Python 3, Java or Kotlin program, an Android app, an Arduino sketch, bare-metal C for an AVR, PIC32 or STM32 chip, or SystemVerilog, Verilog or VHDL for an FPGA.
Download 0.10.1 Source on GitHub
Windows, macOS and Linux. Free and open source, MIT license.
Start, Set, Input, Print, If/Else, For, While and Do-While are blocks; the wires between them are the
control flow. Press Run and the active block lights up as it executes. Expressions work on numbers and
text, with && || !, comparisons and the usual arithmetic.
A class has fields with initial values, a constructor and methods, and each method is its own block
diagram from Enter to Exit. Every Exit becomes an output of the calling block. Blocks that use the same
object name share one object. Save classes as modules (.eviam) and import them into other
programs.
A diagram says what the program does, not what it is written in. The same canvas becomes eight C and C++ standards, Python 3, Java, Kotlin, an Android app, an Arduino sketch, bare-metal AVR, PIC32 or STM32 C, or SystemVerilog, Verilog-2001 and VHDL for an FPGA, and Run executes the diagram itself, so you can compare its output with any of them. Where a target cannot keep a block, the error names that block instead of quietly changing what the program means.
Pick C99, C11, C17, C++98, C++11, C++14, C++17 or C++20 from the toolbar. Structured writes if/else,
loops and switch; Goto turns every block into a label and every wire into a jump.
Safe values keep text and every check of the interpreter; Fast values are plain
doubles with no runtime checks. The C runtime contains only what your program uses, so it
compiles cleanly with -Wall -Wextra -Wpedantic -Werror.
Choose Python 3 and the same diagram becomes one .py file that runs on Python 3.8 or newer, with no packages and no compiler. Classes become Python classes and program variables module globals; Run in the code window starts the program, and text typed into Input goes to it. Python has no goto, so Structured writes if/else and while loops and Goto becomes a small state machine with one branch per block. Print, Input, the number text and every error message are the interpreter's own.
Right-click a block and choose View source code: the generated file opens with exactly the lines that block became highlighted. It works for a whole method or class too, in whichever language you chose. Compile & Run builds it with Clang or GCC right there; on Windows the app installs llvm-mingw or WinLibs GCC for you, no Visual Studio needed.
Pin Mode, Digital Write and Read, Analog Read and Write, Delay and Millis are blocks too. One Arduino sketch builds for the Uno, Nano, Mega 2560, Leonardo, Micro and Pro Mini, and for the ESP32, ESP32-S2, -S3, -C3, -C6 and -H2. UART, SPI, I2C and MQTT are blocks as well. Run simulates an Uno on your computer, with every pin change in the output, so you can try a program before there is a board on your desk.
AVR C writes the program for the ATmega328P, ATmega2560 or ATmega32U4 without the Arduino core: ports, timers, PWM, the ADC and the UART are set up in plain C that you can read. avr-gcc builds it in about 4 KB, and Upload sends it to the board with avrdude. Every example is run in the simavr simulator and checked against the interpreter.
New in 0.5: PIC32 C does the same for nine PIC32MX chips with Microchip's XC32, and UART, SPI and I2C are blocks, in Run and in all three board languages. The PIC32 code is checked against Microchip's device headers, but has not yet been built with XC32 or run on a chip.
New in 0.6: FPGA support. SystemVerilog, Verilog-2001 and VHDL turn the same diagram into hardware for Artix-7 (Nexys A7, Arty A7, Basys 3) and Cologne Chip GateMate boards. The output is simulated against Run and synthesised with open-source tools, but has not been run through Vivado or loaded onto a board.
New in 0.6.5: MQTT. Five blocks publish a program's numbers to a broker and read commands back: on a PIC32MX with a WiFi module on UART2, on an ESP32 with its own WiFi, and in Run against a broker on your computer. Two examples come with it, one of them for the PIC32 Ethernet Starter Kit II. The generated client is checked against a real broker; no WiFi module or chip was part of that. New in 0.6.7: MQTT can also leave through the chip's own Ethernet port on the MX695, the MX795 and the starter kit, as an MPLAB X Harmony application — experimental, and not yet built against real Harmony. The interface itself is now in English, Russian or Armenian too, chosen in Settings.
New in 0.6.9: Python 3. The same diagram becomes one .py file that runs on Python 3.8 or newer with nothing to install, and Run in the code window starts it. Its output, errors and exit code match the interpreter's, like every C and C++ standard.
New in 0.7.0: Settings live in the File menu, with one page per device family — General, C, C++ and Python, Arduino, ESP32, AVR C, PIC32 and FPGA — and Open Example has separate Arduino, ESP32 and PIC32 submenus that also pick the matching language and board.
New in 0.8.0: the installers bring their toolchains — avr-gcc with avrdude, and the OSS CAD Suite for FPGAs — so bare-metal AVR C and the FPGA flows work with nothing to set up. Microchip's free XC32 installs from inside the application (Settings, PIC32, Get XC32), straight from microchip.com. Settings and Devices are now menus of their own.
New in 0.7.1: an AppImage for any Linux on x86-64, next to the .deb — one executable file with the Java runtime inside it, nothing to install and no root needed. The modules a board program can use are described above: UART, SPI, I2C and MQTT.
New in 0.9.0: STM32. The Blue Pill, Black Pill, Nucleo-F401RE, Nucleo-F411RE and STM32F4DISCOVERY take the same diagrams as bare-metal STM32 C (registers only, its own start-up code and linker script) or as Arduino sketches with STMicroelectronics' core, and Upload sends them through an ST-Link with OpenOCD. The installers are now small online installers: the toolchains — arduino-cli, avr-gcc, the Arm GNU Toolchain, OpenOCD and the OSS CAD Suite — are packages of the EVIA server, picked on the first start and updated in place from Settings, Packages and Updates, and the application updates itself the same way. The STM32 code is built with arm-none-eabi-gcc and run in QEMU in CI, but has not yet been run on a board.
New in 0.10.0: Java, Kotlin and Android. The same diagram becomes a Java or Kotlin program, compiled and run from the code window, or an Android app that EVIA Paradigma builds without Gradle and installs on a phone over USB. The JDK and the Kotlin compiler are packages of the EVIA server; the Android SDK comes from Google once you accept its licence.
New in 0.10.1: the phone's sensors. A Phone Sensor block reads the accelerometer, the gyroscope and the GPS of an Android phone, and Run simulates them. File, Open Example, Android Phones has three apps to start from: Hello world, a GPS viewer and a motion tester.
UART sends and receives bytes or lines on a chosen port, and is what Print writes to on a board. SPI transfers a byte or a buffer as master, with the mode and clock you pick, and a chip-select pin per device. I2C reads and writes registers by device address, which is how most sensors are driven. MQTT is five blocks — Connect, Publish, Subscribe, Has Message, Read — that put a program's numbers on a broker and take commands back, over a WiFi module on UART2, an ESP32's own WiFi, or a PIC32's Ethernet port as a Harmony application. Each module is a block in the palette rather than a library to install, works the same in Run as on the chip, and is refused by name on a target that cannot do it instead of compiling into something that silently will not work.
File, New Project creates a folder with the program, a modules folder, a README and a Git repository. Commit, push and pull from the Git menu; Connect to GitHub publishes the project using the login your git already has. The app never asks for or stores a password.
evia --run program.evia and evia --gen program.evia --lang c11 -o program.c for scripts and Makefiles.The full walk-through, with every screenshot, is a PDF in seven languages: English, Русский, Հայերեն, Deutsch, 简体中文, 繁體中文, 日本語. It is also under Help, Tutorial in the app, and in the README.
File, New Project. Keep Create a Git repository checked.
Drag Set, For and Print onto the canvas, wire them, press Run.
Edit, New Class: give Counter the fields total and calls.
Drag Counter.add(x) into the loop and name its object c.
Right-click a block, View source code.
Switch to C11 or any C++ standard; the code is generated again.
Git, Commit, then Connect to GitHub.
Modules, examples and the guide (F1).
Any diagram runs as Python. All it needs is Python 3.8 or newer from python.org, which EVIA Paradigma finds by itself.
Pick Python 3 in the Language list, in the toolbar or in the code window.
Press F7. Right-click a block and choose View source code to see the lines it became.
Press Run. Text typed into Input goes to the program, and an error stops it with the same message as in the editor.
Save writes the file, and it runs anywhere with python3 program.py.
java -jar evia-paradigma.jar --gen examples/tutorial.evia --lang python -o tutorial.py
python3 tutorial.py
# goto flow and fast values work too
java -jar evia-paradigma.jar --gen examples/tutorial.evia --lang python --flow goto --values fast -o tutorial.pySettings, Python holds the command: python3, the py launcher on Windows, or a full path. Detect looks for it again and Check shows its version.
The same diagram becomes a Java or Kotlin program, or an app for an Android phone. Settings fetches a JDK and the Kotlin compiler with one click, and the Android SDK from Google once you accept its licence.
Pick it in the Language list, in the toolbar or in the code window, and press F7 to see the code.
For Java and Kotlin, press Compile & Run in the code window. Text typed into Input goes to the program.
Build makes the APK in seconds with the Android SDK's own tools, without Gradle or Android Studio. The folder still opens in Android Studio.
Turn on USB debugging, connect the phone and press Install on Phone. The app starts by itself: Print on the screen, Input in a text field.
java -jar evia-paradigma.jar --gen examples/tutorial.evia --lang java -o Program.java
java Program.java
java -jar evia-paradigma.jar --gen examples/tutorial.evia --lang kotlin -o tutorial.kt
java -jar evia-paradigma.jar --android examples/tutorial.evia ~/apps/tutorial --installSettings, Java and Kotlin holds the JDK and kotlinc; Settings, Android holds the SDK, the app's id and name, and the phone. The Java and Kotlin output matches the interpreter in CI; the apps are checked on the computer but have not yet been run on a phone.
The same blink diagram becomes hardware for Artix-7 and GateMate boards. The full tutorial, step 10, is in the PDF above, and the guide has an FPGA topic (F1).
Language: SystemVerilog, Verilog-2001 or VHDL. Board: Nexys A7, Arty A7, Basys 3, or a GateMate board.
File, Open Example, FPGA Boards, Blink. Pins are names such as LED0, SW3, BTNC and JA1.
Press F7. The pin constraints are in the first comment, and the command line writes them as a separate file.
Vivado or the open-source tools, chosen in Settings. Upload programs the board.
java -jar evia-paradigma.jar --gen examples/fpga/blink.evia --lang sv --board nexys-a7-100t -o blink.sv
# writes blink.sv and blink.xdc
java -jar evia-paradigma.jar --gen examples/fpga/blink.evia --lang vhdl --board olimex-gatemate -o blink.vhd
# writes blink.vhd and blink.ccfChecked against the interpreter in simulation, and synthesised with open-source tools. Not yet run through Vivado or on a real board.
Each installer brings its own Java runtime, so nothing else needs to be installed. To compile the generated code you need Clang or GCC (the app sets either up on Windows); generated Python needs only Python 3.8 or newer.
| System | File | Notes |
|---|---|---|
| Windows 10 / 11, x64 | EVIA-Paradigma-0.10.1-windows-x64.exe | Not code-signed yet: on the SmartScreen warning choose More info, Run anyway. |
| macOS, Apple Silicon | EVIA-Paradigma-0.10.1-macos-arm64.dmg | Not notarized by Apple yet: if macOS won't open it, choose Open Anyway in System Settings, Privacy & Security. |
| macOS, Intel | EVIA-Paradigma-0.10.1-macos-x64.dmg | Not notarized by Apple yet: if macOS won't open it, choose Open Anyway in System Settings, Privacy & Security. |
| Ubuntu 22.04+ / Debian 12+ | evia-paradigma_0.10.1_amd64.deb | sudo apt install ./evia-paradigma_0.10.1_amd64.deb |
| Any Linux, x86-64 | EVIA-Paradigma-0.10.1-x86_64.AppImage | Nothing to install: make it executable and run it. No root and no package manager, so it suits Fedora, Arch, openSUSE or a live system. |
| Any system with Java 25 | evia-paradigma-0.10.1.jar | java -jar evia-paradigma-0.10.1.jar |
On every change, CI generates every example and test program in all 44 combinations of language, flow and values, compiles it with warnings as errors (Python: checks it), runs it, and compares stdout, stderr and the exit code with the interpreter.
| Where | Compiler | Identical to the interpreter |
|---|---|---|
| Linux, all 8 C and C++ standards | Clang 23 | 416 of 416 |
| Linux, all 8 C and C++ standards | GCC 13 | 416 of 416 |
| Linux, Python 3: every example and test, both flows, both value modes | Python 3.12 | 54 of 54 |
| Linux, Java and Kotlin: every example and test, both flows, both value modes | JDK 25, Kotlin 2.4 | 108 of 108 |
| Android apps: the program part run on the computer, every example and test | Kotlin 2.4 | 54 of 54 |
| Windows, C99, C17, C++98, C++14, C++20 | llvm-mingw Clang 23, static | 260 of 260 |
| Windows, C99, C17, C++98, C++14, C++20 | WinLibs GCC 16, static | 260 of 260 |
| Board examples, bare-metal AVR C in simavr (ATmega328P, 2560, 32U4) | avr-gcc 14 | 30 of 30 |
| Arduino Uno and Mega 2560 sketches in simavr | arduino-cli, arduino:avr | 15 of 15 |
| FPGA designs in simulation (SystemVerilog, Verilog-2001, VHDL) | Icarus Verilog, GHDL | 27 of 27 |
The Arduino sketches are also built for all 12 boards, ESP32 included (70 builds, no warnings). The PIC32 examples are compiled syntax-only against Microchip's device headers (144 of 144). Every FPGA example and test is synthesised with yosys for Artix-7, and the GateMate designs are placed, routed and packed into bitstreams; Vivado, openXC7 and real boards are not part of CI. The MQTT client is compiled on the build machine and run against a real broker. Plus checks of the application, modules, projects, Git, and zooming and panning on a real window. See GitHub Actions.
java -jar evia-paradigma.jar --run program.evia
java -jar evia-paradigma.jar --gen program.evia --lang c11 -o program.c
clang -std=c11 -O2 -o program program.c -lm