Source: https://mokxi.com/docs/start/importing
Updated: 2026-10-03

Getting started Getting started The screen, part by part Your first project in five minutes Save, share, and come back Import a project from another tool The editor Boards Parts Accounts and plans Live collaboration Classrooms Lessons and the learning game Troubleshooting Reference

Docs / Getting started / Import a project from another tool

# Import a project from another tool

Bring a project over from Wokwi, Fritzing, SimulIDE, Falstad CircuitJS, Tinkercad, PlatformIO or the Arduino IDE without placing every part again.

## Where to import

Open the import page, or in the editor open the Save menu and
choose Import a project. You can also drop files straight onto the
editor, or paste text into the import box. Mokxi works out what the project
is from what is inside it, not from its name. Nothing replaces the project on
the canvas until you press Open in the editor, and the project that was
open is kept in this browser: Save > Back to my last project opens it
again.

Every import ends with the same report: what came across, what became a note
on the canvas, and what is missing (connections, files and libraries), each
with the reason.

## From Wokwi

Use any of these:

- A link. Paste a public project link, such as
https://wokwi.com/projects/322062421191557714. Mokxi's server fetches the
project's files from wokwi.com, and only from there, and your browser reads
them. A private project cannot be fetched by anyone but you: open it on
Wokwi, download the project zip, and drop that instead.

- The files. Drop or choose diagram.json, the sketch (sketch.ino or
whatever it is called), any extra .h and .cpp tabs, and libraries.txt.

- The zip. Wokwi's downloaded project zip works as it is.

What comes across:

- Parts. Boards, LEDs, resistors, buttons, slide switches, potentiometers,
servos, buzzers, character LCDs (with or without the I2C backpack), OLEDs,
NeoPixels, rings and strips, seven-segment and TM1637 displays, MAX7219
matrices, ILI9341 screens, the HC-SR04, DHT22, PIR, DS18B20, MPU6050, DS1307
and HX711, keypads, rotary encoders, joysticks, relays, stepper drivers and
motors, shift registers, microSD cards and logic gates become the matching
Mokxi part, with their color, value, I2C address and pixel count.

- Wires. Every connection between two parts that map becomes a wire, with
the pin names translated (GND.2 is the board's second GND pin, V+ on a
servo is VCC, and so on) and the nearest Mokxi wire color. Wires are drawn
with simple corners; press Tidy wires to route them around the parts.

- Breadboards. A part plugged into a Wokwi breadboard is plugged into the
same holes on a Mokxi breadboard. Where the Mokxi part is a different size
(a resistor is shorter here), one leg sits in its hole and the rest are wired
to theirs.

- Labels. A Wokwi text label becomes a sticky note.

- Code. The sketch and its tabs become the board's files.

What does not, and how you are told:

- Parts Mokxi does not have yet (the photoresistor and NTC modules, the
analog multiplexer, the BMP180 and custom chips, for example) become a pink
note on the canvas where the part stood, naming it. Their wires are listed in
the report.

- Wokwi's serial monitor connections are left out: Mokxi's serial monitor
is always connected to the board.

- MicroPython projects are kept as text, but Mokxi builds Arduino C++
sketches, so they do not run.

## From Fritzing

Drop the .fzz file (File, Save in Fritzing writes one). It is a zip holding
the sketch and the code from Fritzing's Code tab, and both come across. A bare
.fz works too, with the .ino dropped beside it.

- What is read. The breadboard view: every part, where it stands, every
wire, and the breadboard's strips. The schematic and PCB views are not read,
since a wire drawn only there was never on the breadboard; the report counts
any parts that are only there.

- Parts. Fritzing's core library: the Arduino Uno, Nano and Mega 2560,
resistors with their value, LEDs with their color, RGB LEDs, pushbuttons,
toggle, tilt and reed switches, potentiometers, ceramic and electrolytic
capacitors, diodes and zeners, NPN and PNP transistors, an N-channel MOSFET,
the 7805 regulator, LDRs, thermistors, the LM35, FSRs, the HC-SR04, the
RHT03 (DHT22), piezo speakers, servos, DC motors, the 16x2 LCD, a
seven-segment display, the 555, the 74HC595, the L293D H-bridge and 9 V and
AA batteries.

- Breadboards. The breadboard itself is not brought across. The parts in
each of its strips are joined by wires instead, which connects exactly the
same pins. Press Tidy wires to route them.

- Notes. Fritzing's notes become sticky notes.

- Parts from other libraries, and custom parts, become a pink note naming
them.

## From SimulIDE

Drop the circuit file: .sim1 from SimulIDE 1.0 on, or .simu from older
versions.

- What is read. Every component, where it stands and how it is turned,
every wire, junction nodes, and tunnels (two tunnels with the same name are
one connection). Text labels become sticky notes.

- Parts. Resistors, capacitors, inductors, LEDs, diodes and zeners,
potentiometers, LDRs, thermistors, ground, fixed voltages, rails and
batteries, BJTs, MOSFETs, op-amps, the LM555, push buttons and switches, DC
motors, servos, the DHT22, the HC-SR04, the HD44780 LCD, seven-segment
displays, two-input AND, OR and XOR gates, clocks, and the Arduino Uno, Nano
and Mega (their pins are read by label, such as D13 and A0).

- Code. SimulIDE keeps the sketch in its own editor and loads a compiled
.hex into the board, and Mokxi builds from source, so put the .ino in the
folder or zip with the circuit. The report says when only the .hex path
was there.

## From Falstad CircuitJS

Use any of these:

- A link. Paste a CircuitJS link with ?ctz= or ?cct= in it, from
File, Export As Link. The circuit is stored in the link itself, so Mokxi
reads it there and fetches nothing.

- The text. Paste the text from File, Export As Text, or drop a saved
circuit file. Both the long-standing text format and the newer XML format
are read.

What comes across: resistors, capacitors, inductors, DC sources and rails,
sine, square, triangle, sawtooth and pulse sources (as a generator), ground,
switches, diodes, zeners, LEDs with their color, NPN and PNP transistors,
MOSFETs, op-amps, potentiometers, the 555, LDRs, thermistors, DC motors,
two-input logic gates, inverters, logic inputs and outputs, and voltmeters and
ammeters (as a multimeter). Labeled nodes join every node with the same name,
and text becomes a sticky note.

Two things are different in Mokxi, and the report says so: a CircuitJS op-amp
is powered without wires, so the import adds a supply and a ground for it; and
CircuitJS needs no ground symbol, so add one where the circuit's 0 V is if it
had none. Every other element (transformers, transmission lines, custom
subcircuits and the like) becomes a pink note naming it.

## From Tinkercad

Tinkercad Circuits keeps projects on its own servers and has no file that
says how a circuit is wired, so a Tinkercad project cannot be imported whole.
Here is how to bring over what Tinkercad lets you take:

- The code. Open the project in Tinkercad, open Code, switch to
Text, select all of it and copy it. (Or use the download button there
to save the .ino.)

- The parts. Open the Component List view and copy the table, or
download it as CSV.

- Paste both into the import box on the import page, the list
first and the code below it, or drop the .csv and .ino together.

Mokxi places every part the list names that it has (the Uno, LEDs with their
color, resistors and potentiometers with their value, buttons, switches,
piezos, servos, motors, the TMP36, photoresistors, the HC-SR04, PIR, LCDs,
seven-segment displays, the 74HC595, the 555, the L293D, transistors and
more) in rows, and puts the code on the board. The list has no wiring in it,
so wire the parts the way your Tinkercad circuit has them. Components Mokxi
does not have are named in the report. Mokxi never reads Tinkercad's pages.

## From PlatformIO

Drop the project folder, or a zip of it, with platformio.ini at the top.

- The board comes from the environment that builds by default
(default_envs, else the first [env:...]), its board read the same way
the PlatformIO export writes it, and you can pick another.

- The code. src/main.cpp becomes the board's sketch.ino (its
#include <Arduino.h> and declarations work as they are), and the other
files in src/ and include/ come beside it. Files in folders inside
src/ do not, since a Mokxi project has no folders.

- Libraries. Each lib_deps entry is checked like a Wokwi
libraries.txt line, and the project's own libraries in lib/ come along
as the project's own libraries. A library PlatformIO fetches from a Git URL
is named as missing.

- Other frameworks. Mokxi builds Arduino sketches; the report says so when
the project uses another framework, such as ESP-IDF.

## From the Arduino IDE

Drop an .ino, the whole sketch folder, or a zip of it, or paste the sketch
into the import box. Every .ino, .h, .cpp and .c tab next to the
sketch comes across. Files in folders inside the sketch (such as src/) do
not, since a Mokxi project has no folders: move them next to the sketch and
include them by name.

The Arduino IDE does not record the board, so Mokxi guesses from the sketch:
WiFi.h or ledcWrite means an ESP32, ESP8266WiFi.h an ESP8266, Serial1
or pin 40 a Mega, A7 a Nano, and so on. Pick the right one from the Board
list before opening. The project starts with just that board on the canvas,
ready for you to wire.

## Libraries

The report checks every library the project names, in Wokwi's
libraries.txt, PlatformIO's lib_deps, and the sketch's #include lines:

- Built in. Mokxi builds with it as it is, such as Servo.h,
LiquidCrystal_I2C.h, Adafruit_SSD1306.h, Adafruit_NeoPixel.h and
DHT.h.

- Use instead. Mokxi has a driver that does the same job under another
name, and the report says which header to include.

- Missing. Nothing in Mokxi provides it.

A zip with a libraries/ folder (the Arduino sketchbook layout), or a
PlatformIO lib/ folder, brings its libraries along as the project's own
libraries. Adding your own libraries is a Pro feature: on Pro they come with
the project; on the Free plan the report names them and the project opens
without them. See plans.

## Taking a project out again

Nothing locks a project in. The Export menu in the editor downloads it as
a Wokwi project (diagram.json, sketch.ino and libraries.txt, zipped), an
Arduino IDE sketch folder or a PlatformIO project. The Wokwi export brings the
parts and wires as well as the code; parts Wokwi has no match for are listed
in its README, and a breadboard's strips become direct wires.

## Safety

Nothing you import is run while it is read. Uploads, zips and pasted text are
size capped; a path that climbs out of the project (../) or starts at a
drive is refused and named in the report; only source and project files are
kept; XML files that declare a document type or entities are refused, so no
entity is ever expanded or fetched; a CircuitJS link is unpacked with a cap;
and library files meet the same rules as a library uploaded in the editor.

### On this page

Where to import From Wokwi From Fritzing From SimulIDE From Falstad CircuitJS From Tinkercad From PlatformIO From the Arduino IDE Libraries Taking a project out again Safety