DocsOpen the editorEditor

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:

  1. 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.)
  2. The parts. Open the Component List view and copy the table, or download it as CSV.
  3. 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.