EVIA Paradigma v0.12.1

EVIA Paradigma 0.12.1

The evia command in every installer. 0.12.0 added the evia command (evia gen, watch, check, run,
langs, boards ...; see the 0.12.0 notes), but only the Windows installer had a launcher for it.

• Linux (.deb): /usr/bin/evia, next to evia-paradigma (left alone if another package already owns
  /usr/bin/evia). The AppImage takes the same commands: ./EVIA-Paradigma-0.12.1-x86_64.AppImage gen app.evia -l python.
• macOS: /Applications/EVIA Paradigma.app/Contents/MacOS/evia; to type just evia:
  sudo ln -s "/Applications/EVIA Paradigma.app/Contents/MacOS/evia" /usr/local/bin/evia.
• Windows: evia.exe in the install folder, as before; it now takes the subcommands.
• Any OS with Java 25: java -jar evia-paradigma-0.12.1.jar gen app.evia -l python.

An update package: 0.9.0 to 0.12.0 take it from Settings → Packages and Updates… (the evia launcher itself
comes with the installer).

EVIA Paradigma v0.12.0

EVIA Paradigma 0.12.0

The evia command: the code generators on the command line, with subcommands. An update package: 0.9.0 to
0.11.1 take it from Settings → Packages and Updates… and start 0.12.0 the next time.

evia

evia gen app.evia -l python -o app.py               # one language (standard output without -o)
evia gen app.evia -l c11,python,java,kotlin -d out/ # several: out/app.c, app.py, app.java, app.kt
evia gen blink.evia -l arduino -b uno -o blink/blink.ino
evia gen top.evia -l sv -b basys3 -o top.sv         # also writes top.xdc
evia watch app.evia -l python -o app.py             # write it again every time app.evia is saved
evia check app.evia                                 # does it generate for every language? (exit code 0/1)
evia run app.evia | native app.evia | android app.evia DIR | new hello.evia
evia langs | boards [LANG] | packages | install ID | remove ID | version | help [gen|watch|check]

• gen and watch take -l LANGS (comma separated, or all: C99 to C++20, Python, Java, Kotlin), -o FILE,
  -d DIR, -b BOARD, --flow structured|goto, --values safe|fast, --net uart|ethernet and -q.
  Two languages with the same file type get the language in the name: app-c11.c, app-c17.c.
• A board that does not fit the language is refused (evia boards stm32 lists the ones that do).
• The installers' evia / evia.exe launcher now starts this command: evia alone prints the help instead of
  opening the editor. With the plain jar: java -jar evia-paradigma.jar gen ..., or scripts/install-cli.sh, which
  puts the jar in ~/.local/share/evia and the launcher packaging/cli/evia in ~/.local/bin (evia.cmd for
  Windows is next to it).
• The older options all still work, also as evia --gen ..., evia --linux ....

Checks

• scripts/check-targets.sh (C11, C++20, Python, Java): 216 programs identical to the interpreter, 0 failed.

EVIA Paradigma v0.11.1

EVIA Paradigma 0.11.1

Native executables, and EVIA Paradigma Native. The blocks now compile straight to machine code: no C, no compiler,
no assembler, no linker. An update package: 0.9.0 to 0.10.1 take it from Settings → Packages and Updates… and
start 0.11.1 the next time.

0.11.1 is 0.11.0 with its macOS installers, which the 0.11.0 build did not make (an empty list in the packaging
script that macOS's older bash rejects); 0.11.0 was not released.

A compiler from blocks to machine code

• --native program.evia -o program writes a Linux x86-64 executable: a static ELF file of about 33 KB that talks
  to the kernel with system calls only (no libc, no shared libraries), so it runs on any x86-64 Linux.
• It behaves as the interpreter does, exactly: the same output, the same error messages on stderr (>> error: ...),
  the same exit code, the 400-call limit on nested methods, Input with its prompt. Numbers are written as Java writes
  them (the shortest digits that read back: 0.30000000000000004, 1.0E-5, 4.9E-324) and read as
  Double.parseDouble reads them, correctly rounded, with exact big-number arithmetic.
• Safe values (numbers and text with every check) and fast values (plain doubles), classes and objects, every flow
  block, Delay and Millis. The board, bus and phone blocks need their own languages.
• Inside: the blocks are lowered to a small internal language, every block a label and every wire a jump; the
  runtime is written in the same language (strings, buffered output, Input, big whole numbers for the number
  conversions); NativeAsm encodes x86-64 and NativeElf writes the file. Nothing outside EVIA Paradigma is used.

EVIA Paradigma Native

A second application, now a project of its own forked from this release, with its own installers and releases:
EVIA Paradigma Native 1.0.0. It is the editor, blocks, classes, projects, Git and Run, without the
Language list and the code window.

• Build executable (F7) and Run executable (F6), with Input typed in a field under the output; the program goes
  to the project's build/ folder, or next to the program file.
• Values: Safe / Fast in the toolbar; the palette has the program blocks and Delay and Millis.
• It installs next to EVIA Paradigma (/opt/evia-paradigma-native, command evia-paradigma-native); .evia files
  stay with EVIA Paradigma. In EVIA Paradigma the same compiler is on the command line: --native.
• On Windows and macOS it builds the same Linux executables (Windows and ARM executables are next).

Checks

• scripts/check-native.sh: every example and test program, safe and fast, compiled and run against the
  interpreter (27 of 27), and 100,000 numbers read and written exactly as Java does. In CI on every push.
• The Native edition's installers are smoke-tested by building and running an executable.

EVIA Paradigma v0.10.1

EVIA Paradigma 0.10.1

Android examples and the phone's sensors. An update package: 0.9.0 to 0.10.0 take it from Settings → Packages
and Updates… and start 0.10.1 the next time.

Phone Sensor block

A new block in the palette group Phone stores a reading of the phone in a variable, e.g. ax = ACCEL_X:

Sensor	What it is
ACCEL_X, ACCEL_Y, ACCEL_Z	acceleration in m/s², gravity included (about 9.81 on Z when the phone lies flat), 0.01 resolution
GYRO_X, GYRO_Y, GYRO_Z	rotation in rad/s, 0.001 resolution
LATITUDE, LONGITUDE	the position in degrees, 6 decimals
ALTITUDE, GPS_ACCURACY	metres, 0.1 resolution
GPS_FIX	1 once the position is known, 0 before

• Language Android reads the real accelerometer, gyroscope and GPS (the network position until the GPS has a fix).
  An app that reads the position asks for the location permission when it starts; one that does not never asks.
• Run simulates a phone lying on a table in Yerevan that rocks gently, following the simulated clock, so a program
  can be tried on the computer first.
• Other languages say that the block needs Language Android instead of compiling something that cannot work.
• Delay and Millis now work in Java, Kotlin and Android too (on a phone, closing the app ends a Delay).

Examples

File → Open Example → Android Phones (they also switch the language to Android):

• Hello, world: prints in three languages and asks for a name.
• GPS viewer: the position once a second: latitude, longitude, altitude and accuracy, or a note while there is no fix.
• Motion tester: the accelerometer and gyroscope twice a second, with shake! on a strong jolt and face down when
  the phone is turned over.

Checks

• check-android.sh compiles the three examples' apps too and runs Hello world against the interpreter.
• The apps have been checked on the computer; they have not yet been run on a phone.

EVIA Paradigma v0.10.0

EVIA Paradigma 0.10.0

Java, Kotlin and Android. The same diagrams now become a Java or Kotlin program, or an app for an Android phone.
An update package: 0.9.0 to 0.9.5 take it from Settings → Packages and Updates… and start 0.10.0 the next time.

Java and Kotlin

• Language → Java writes one file with class Program (JDK 17 or newer, nothing else); Language → Kotlin one
  .kt file. Compile & Run in the code window compiles and runs them; text typed into Input goes to the program.
• Neither language has goto: Structured flow writes nested if/else and while loops, and where the wiring is
  not block-structured (and always in Goto flow) the diagram becomes a state machine with one branch per block.
• Safe values (numbers and text, the interpreter's checks) and Fast values (plain doubles) work as in C++. The
  output, error messages and exit code are the interpreter's, for every example and test in both flows and both value
  modes (108 of 108). The Java compiles with javac -Xlint:all -Werror (also for Java 17), the Kotlin with
  kotlinc -Werror.
• Settings → Java and Kotlin: the JDK is found by itself (JAVA_HOME, or the javac on PATH); Get downloads
  Eclipse Temurin 25 and Kotlin 2.4.21. Both are new packages of the EVIA server (jdk, kotlin).
• Command line: --gen program.evia --lang java -o Program.java (then java Program.java), --lang kotlin.

Android apps

• Language → Android (or Devices → Android Phones and Tablets) makes an Android app of the program: Print lines
  appear on the screen, Input asks in a text field with OK, and Run again starts the program over. Android 7.0 and
  newer.
• In the code window, Build makes the APK and Install on Phone installs it over USB with adb and starts it.
  EVIA Paradigma builds the app itself with the Android SDK's tools (aapt2, kotlinc, R8, zipalign, apksigner) in a few
  seconds: no Gradle and no Android Studio needed, and R8 keeps the APK at tens of kilobytes.
• The folder it writes (the project's build/android, or EVIA Projects/Android/<program>) is also an ordinary
  Android Studio project (Gradle, Android Gradle plugin 9.5).
• Settings → Android: the SDK folder (Android Studio's is found by itself), Get Android SDK…, the application id
  (e.g. am.evia.counter), the name under the icon, and the phone when several are connected.
• Get Android SDK… shows Google's licence, the text from Google's own SDK index, and once you accept it downloads
  platform android-37.0 (Android 17), build-tools 37.0.0 and platform-tools from Google (about 140 MB). Google's
  licence does not allow passing the SDK on, so it is not a package of the EVIA server.
• Command line: --android program.evia DIR [--package ID] [--name TEXT] [--build | --install], and
  --android-sdk [--accept-license] to fetch the SDK.

Checks

• check-targets.sh covers Java and Kotlin; CI installs Kotlin 2.4.21.
• The new check-android.sh compiles the app of every example against an Android platform, runs its program part on
  the computer with the console in place of the screen and compares it with the interpreter (54 of 54), and builds one
  APK when the SDK is there.
• A new test program with Russian and Armenian text, $ and backslashes, for every language.
• The apps have been checked on the computer; they have not yet been run on a phone.

EVIA Paradigma v0.9.5

EVIA Paradigma 0.9.5

Two more boards: the chipKIT Pro MX7 (PIC32 C) and the 32F429IDISCOVERY (STM32 C and Arduino). An update
package: 0.9.0 to 0.9.4 take it from Settings → Packages and Updates… and start 0.9.5 the next time.

chipKIT Pro MX7 (PIC32 C)

Digilent's chipKIT Pro MX7, formerly the Cerebot MX7cK: a PIC32MX795F512L with four LEDs, three buttons, a
USB-UART and an Ethernet PHY.

• LED_BUILTIN is LD1 (RG12); LD2–LD4 are RG13–RG15, BTN1/BTN2/BTN3 are RG6/RG7/RA0 (the pin names work as they
  are, e.g. RG13).
• Print and Input go over UART1 (RF2/RF8), the board's USB-UART, at 115200 baud.
• MQTT over Ethernet (Settings → PIC32 → PIC32 MQTT over → Ethernet) is allowed for it: the board's PHY is a
  LAN8720 (choose that one in Harmony's MAC driver).
• Upload uses the PIC32 upload command, e.g. a PICkit with pic32prog or ipecmd (Settings → PIC32 → Programmer).
• In the Board list, under Devices → PIC32 Chips, and on the command line as --board chipkit-pro-mx7.

32F429IDISCOVERY (STM32)

ST's STM32F429I-DISC1: an STM32F429ZI, 2 MB flash, 256 KB RAM, with an ST-LINK/V2-B.

• STM32 C: 168 MHz from the internal oscillator (the F407's clock setup, which the F429 runs without its
  over-drive), a linker script for 2048 KB of flash and the 192 KB of SRAM from 0x20000000 (the 64 KB CCM RAM is not
  used), Print and Input on USART1 (PA9/PA10): the ST-LINK's virtual serial port, so the board's one USB cable
  carries both upload and output.
• LED_BUILTIN is LD3, the green LED (PG13); LD4 is red on PG14, the user button B1 is PA0.
• Arduino: STMicroelectronics' core, STMicroelectronics:stm32:Disco:pnum=DISCO_F429ZI.
• Upload with OpenOCD through the ST-LINK (target/stm32f4x.cfg), as for the other STM32 boards.
• On the command line: --board disco-f429zi.

Checks

• check-pic32.sh builds every example for the Pro MX7 too, with the WiFi module and with Ethernet (212 checks).
• check-stm32.sh builds every example for the F429 Discovery with clang and arm-none-eabi-gcc (vector table at
  0x08000000) and its Arduino sketches (96 STM32 C checks, with QEMU).
• Neither board has been tried on real hardware yet.

EVIA Paradigma v0.9.4

EVIA Paradigma 0.9.4

PIC32 upload with Microchip's ipecmd (MPLAB IPE), for the boards pic32prog cannot program: the
PIC32MX Ethernet Starter Kit II (its on-board programmer), the PICkit 4 and 5, the ICD 4 and 5 and the Snap.
An update package: 0.9.0 to 0.9.3 take it from Settings → Packages and Updates….

Settings → PIC32

• Programmer sets the upload command: pic32prog (PICkit2, PICkit3 in PICkit2 mode, bootloaders), or ipecmd for
  the starter kit's on-board programmer (ipecmd -TPPKOB -P{chip} -M -F{hex} -OL), PICkit 3/4/5, ICD 4/5 or Snap.
  {chip} is the chip chosen above, e.g. 32MX795F512L for the Ethernet Starter Kit II; -OL lets the program run
  after programming.
• Get MPLAB IPE… installs IPE from Microchip's MPLAB X v6.20 installer. IPE is Microchip's software: its
  licence does not let EVIA Paradigma pass it on, and Microchip's site lets the installer be downloaded only in a
  browser. So the button opens Microchip's page, you choose the downloaded installer, and EVIA Paradigma checks it (on
  Linux: size and SHA-256 of Microchip's published v6.20 file) and runs it for IPE only, with the 32-bit devices
  and nothing sent to Microchip. Your system asks for an administrator password.
• An upload command that starts with plain ipecmd runs the newest IPE in Microchip's usual place
  (/opt/microchip/mplabx/v*/, C:\Program Files\Microchip\MPLABX\v*\, /Applications/microchip/mplabx/v*/), so it
  follows MPLAB X updates.

Also

• On Linux without a password dialog, the same install in a terminal:
  sudo sh MPLABX-v6.20-linux-installer.sh -- --mode unattended --ide 0 --ipe 1 --8bitmcu 0 --16bitmcu 0 --32bitmcu 1 --othermcu 0 --collectInfo 0 --collectMyMicrochipInfo 0
• scripts/check-ipe.sh (in CI): finding ipecmd, the presets and {chip}, the accepted installers and options, and
  (with MPLABX_INSTALLER=) the SHA-256 check.
• Guide and interface in Russian and Armenian.
• Not tested yet on a real Ethernet Starter Kit II: if ipecmd does not take PKOB for it, the upload command can be
  edited in Settings.

EVIA Paradigma v0.9.3

EVIA Paradigma 0.9.3

The Linux build systems of 0.9.2 are now packages of the EVIA server, next to the toolchains. An update package:
an installed 0.9.0, 0.9.1 or 0.9.2 takes it from Settings → Packages and Updates… and starts 0.9.3 the next time
(or at once with Restart Now).

The packages

Package	Version	What is in it	Download
buildroot	2026.02.3 (LTS)	the Buildroot release	8 MB
yocto	5.0.21 Scarthgap (LTS)	Poky (the release tarball) and meta-raspberrypi (018d444 of scarthgap)	18 MB
openwrt	25.12.6	the OpenWrt sources; on x86-64 also the Image Builders for the BeagleBone Black (omap/generic) and Raspberry Pi 5 (bcm27xx/bcm2712)	92 MB (x86-64)

They are in the package panel (group Linux images), for Linux on x64 and ARM64, and the Linux Images window has a
Get Sources… button for the chosen build system. The window says whether the sources are installed.
On the command line: --install buildroot yocto openwrt.

build.sh

• fetch copies the sources from the installed package. Without it, it downloads the same pinned files and checks
  their SHA-256 (it no longer clones a branch, so a folder builds the same thing later). OpenWrt's Image Builder from
  the package is checked against its sha256sums before it is unpacked.
• Yocto is pinned to the 5.0.21 release (it followed the scarthgap branch before).
• EVIA_PACKAGES=/some/folder ./build.sh fetch points a workspace at packages installed elsewhere.
• Workspaces made by 0.9.2 keep their sources; saving them in 0.9.3 writes the new build.sh.

The packages carry the build systems only: a build still downloads the compilers, kernels and packages it builds from
each project's servers.

Checks

scripts/check-linux.sh (55 checks, in CI) also builds workspaces against stand-in packages: the sources are taken
from them, a damaged Image Builder is refused, and the pins in the application and in fetch-toolchains.sh agree.
The three packages were built with build-packages.sh, installed with --install and used by build.sh fetch.

EVIA Paradigma v0.9.2

EVIA Paradigma 0.9.2

A Linux menu, next to Git, that builds your own Linux for open boards (BeagleBone Black and Raspberry Pi 5)
with Buildroot, Yocto or OpenWrt, and writes it to an SD card. An update package: an installed 0.9.0 or
0.9.1 takes it from Settings → Packages and Updates… and starts 0.9.2 the next time (or at once with
Restart Now).

Build systems and boards

Build system	Version	BeagleBone Black	Raspberry Pi 5	First build
Buildroot	2026.02.3 (LTS)	beaglebone_defconfig	raspberrypi5_defconfig	about 1 hour, 15 GB
Yocto (Poky)	5.0 Scarthgap (LTS to April 2028)	beaglebone-yocto	raspberrypi5 (meta-raspberrypi)	hours, about 90 GB
OpenWrt, Image Builder	25.12.6	omap/generic, ti_am335x-bone-black	bcm27xx/bcm2712, rpi-5	minutes, 3 GB
OpenWrt, from source	25.12.6	the same	the same	about 2 hours, 30 GB

The versions are pinned, so a folder builds the same image later. Yocto is 5.0 Scarthgap, the long-term series that
both Poky (the classic one-repository layout) and meta-raspberrypi carry; Poky has no branch for Yocto 6.0.

The Linux menu

• New Linux Image… opens the Linux Images window: build system, board, folder, host name, root password, SSH server
  (Dropbear), Python 3, the LuCI web interface (OpenWrt) and more packages by the build system's names. For Yocto,
  core-image-base or core-image-minimal.
• Build Image downloads the sources the first time, applies the choices and builds, with the output in the window
  (Stop ends it, children included). Menuconfig… opens the build system's own text menu in the desktop's terminal.
• Write Image to SD Card… offers only SD cards and USB drives: never a disk with /, /boot, /home or swap on
  it, never a read-only one. It asks twice, unmounts the card, and writes plain or compressed images (.img, .wic,
  .gz, .bz2, .xz, .zst) through pkexec. Elsewhere it names Raspberry Pi Imager or balenaEtcher.
• Check This Computer lists the missing tools with the apt or dnf line that installs them, the free disk space,
  and for Yocto Ubuntu's AppArmor setting that keeps BitBake from user namespaces and a UTF-8 locale.
• Terminal on the Board opens the 0.9.1 Terminal for the board's UART (115200 baud) or SSH once it has booted.
• Linux Images Guide: a new topic of the guide, in English, Russian and Armenian.

The folder

Each image is a folder (no spaces in its path; the build systems require it):

• evia-linux.json: the choices; Open Linux Image Folder… reads it again.
• build.sh: fetch, configure, build, all, menuconfig, images. It runs by hand too, e.g. on a build
  server or in WSL 2.
• secrets/root-password: owner-only. The image only gets its SHA-512 crypt hash: Buildroot's
  BR2_TARGET_GENERIC_ROOT_PASSWD, Yocto's extrausers, and an OpenWrt first-boot script. Without a password, root
  logs in without one (Buildroot, Yocto) and OpenWrt asks for one in LuCI.
• overlay/ (if you make it): files copied into the root file system (Buildroot and OpenWrt).

Command line: java -jar evia-paradigma.jar --linux DIR --system buildroot|yocto|openwrt|openwrt-source --board bbb|rpi5 [--hostname NAME] [--packages "A B"] [--password-file F] [--python] [--no-ssh] [--web] [--minimal].

Notes

• The builds need Linux (WSL 2 on Windows, a virtual machine on a Mac); the OpenWrt Image Builder needs x86-64.
• BeagleBone Black: hold S2 at power-on to boot from the card instead of the eMMC. Raspberry Pi 5: the debug UART
  is the 3-pin connector between the HDMI ports.
• scripts/check-linux.sh (also in CI) writes all eight combinations and runs their configure steps with stand-in
  tools; it does not download or build the images themselves.

EVIA Paradigma v0.9.1

EVIA Paradigma 0.9.1

A Terminal window for boards and other computers, and the PIC32 uploader as a package. This is the first
update package: an installed 0.9.0 takes it from Settings → Packages and Updates… (it also says so in the
status bar once a day) and starts 0.9.1 the next time, or at once with Restart Now. Nothing is uninstalled.

Terminal

Terminal in the toolbar (also Help → Terminal (UART, SSH)) opens a real terminal emulator, JediTerm (the one in
the JetBrains IDEs), with one tab per session:

• UART: a board's serial port, chosen from a list (Scan finds the ones plugged in) or typed; the baud rate
  (115200 for Print and Input of EVIA programs); what the Enter key sends (CR, LF or CR LF); and local echo for the
  many boards that do not send back what you type. The port is the one Upload uses, so close the tab before uploading.
  On Linux the user needs to be in the dialout group, as for Upload.
• SSH: another computer (a Raspberry Pi, a board running Linux, a server), with a password or a key
  (~/.ssh/id_ed25519 is offered if you have one; a key with a passphrase asks for it). A host seen for the first
  time shows its key fingerprint for you to accept, and is remembered in ~/.ssh/known_hosts, like OpenSSH does.
  The terminal is xterm-256color and follows the size of the window, so colours, cursor keys and full-screen programs
  (top, htop, vim, nano) work.
• The colours follow the light or dark theme; the font is JetBrains Mono.

pic32prog, a package

pic32prog uploads PIC32 programs through a PICkit2, a PICkit3 in its PICkit2
mode, the chipKIT and Microchip bootloaders or an FT2232 JTAG adapter. Its project publishes no builds newer than 2016,
so a workflow of this repository (pic32prog.yml) builds it from a pinned commit for Windows, macOS (Apple Silicon and
Intel) and Linux (x64 and ARM64), with libusb and hidapi linked in, and the package server serves it.

• Settings → PIC32… → Get installs it; the default upload command, pic32prog {hex}, then uses it by itself.
• XC32 still comes from Microchip (Settings → PIC32 → Get XC32): its licence does not allow passing it on.

Also

• The packages: arduino-cli, avr-gcc with avrdude, the Arm GNU Toolchain, OpenOCD, pic32prog and the OSS CAD Suite.
• New libraries in the jar: JediTerm (LGPL v3 or Apache 2.0) with the Kotlin standard library (Apache 2.0),
  jSerialComm (Apache 2.0 or LGPL v3) and JSch (BSD, the maintained mwiede fork). See THIRD_PARTY_NOTICES.md.
• The package server is built without rsync, and the dell workflow rebuilds it after every release.