The fastest way: mokxi.com/ in front of a link
Type mokxi.com/ in front of a Wokwi, CircuitJS, GitHub, gist, GitLab,
Bitbucket, Codeberg, paste site, Dropbox, Google Drive, Instructables, Arduino
Project Hub, Hackster or shared Arduino Cloud link in your browser's address
bar, for example mokxi.com/wokwi.com/projects/322062421191557714, and press
Enter. The editor opens with that project imported. No account is needed. A
Tinkercad link lands on the import page instead, with the steps for
Tinkercad. A Cirkit Designer link does not work this way: paste it into the
import page.
Where to import
Open the import page, or in the editor open the â–¾ beside
Save and choose Import a project. You can also paste a project link, a
diagram.json or a sketch anywhere on the canvas, or drop files, a folder or
a zip straight onto the editor. Mokxi works out what the project is from what
is inside it, not from its name.
What happens when it opens
- The project you had open is kept. Undo on the import's summary line puts it back, and Save â–¾ > Back to my last project opens it later.
- The summary line says what came across. Press it for the full report: what became a note on the canvas, and what is missing (connections, files and libraries), each with the reason.
- Parts Mokxi does not have become pink notes where they stood, and a "Left out:" line in the report names each one.
- Wires are laid out for you. Where the source drew its wires (Wokwi, Cirkit, many Fritzing files), they follow the same route. Where it did not (a schematic, a netlist, a Tinkercad board file), an import of up to 30 wires is laid out with Tidy wires as it opens. A bigger one keeps straight wires: press T to tidy them.
- Mokxi AI can finish it. When something was left out, the summary line offers
Ask Mokxi AI to finish it. Mokxi AI proposes the nearest Mokxi
part for each note, with its pins wired, and the library to install or the
#includeto change for each one that is missing. Every part and pin is checked against the real catalog first. Nothing changes until you press a button on a line (Add to canvas, Install, Change the include), and each press is one step of Undo. - Tell us sends where the project came from and what was missing (never your code). A real person reads every report. An import that fails offers Try again when another try could help.
Sources on this page
Wokwi, Cirkit Designer, GitHub, GitLab, Bitbucket and Codeberg, paste sites, Dropbox and Google Drive, Instructables, Project Hub, Hackster and Arduino Cloud, Fritzing, SimulIDE, KiCad, EasyEDA, Qucs and gEDA, Falstad CircuitJS, Tinkercad, PlatformIO, the Arduino IDE, a compiled .hex file, a Mokxi link, pasted text, a photo, LTspice, and Proteus, Multisim and CircuitMaker.
From Wokwi
Full guide: Import a Wokwi project, with a link that opens imported.
New to Mokxi from Wokwi? Coming from Wokwi puts each Wokwi idea beside its name here, and says what changes.
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.inoor whatever it is called), any extra.hand.cpptabs, andlibraries.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.2is the board's second GND pin,V+on a servo is VCC, and so on) and the nearest Mokxi wire color. A wire follows the route drawn in Wokwi; one with no route gets a single corner. 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:
- Custom chips come across as parts that run their own code when the
chip's files come with them (
<name>.chip.jsonand<name>.chip.c, a barechip.jsonandchip.c, a chip in a folder of its own, or a builtchip.wasm), or whendiagram.jsonnames them underdependencies. See custom chips. A chip's code never becomes a tab of the board's sketch. A chip whose files are missing is a pink note, and the report says what was missing, such as a.chip.cthat came without its.chip.json. - Parts Mokxi does not have yet 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 run on the Raspberry Pi Pico and the classic ESP32
boards (the DevKit V1, the DevKitC and the LOLIN32 Lite). On other boards
the
.pyfiles are kept as text but do not run. - CircuitPython projects (a
code.py) run on the Raspberry Pi Pico and the Arduino Nano RP2040 Connect, on the official CircuitPython firmware. On other boards thecode.pyis kept as text, and the report says why.
From Cirkit Designer
Full guide: Open a Cirkit Designer project link, with the part list and the steps.
Paste a shared project's link (https://app.cirkitdesigner.com/project/<id>,
with or without a version number at the end) into the import page or onto the
canvas. Mokxi's server fetches the project file from Cirkit, and only from
there, with no sign-in. A project that is not shared cannot be read.
- Parts. The Arduino Uno, Nano and Mega, the ESP32 and ESP32-S3, the Raspberry Pi Pico, LEDs and RGB LEDs, resistors with their value, pushbuttons, buzzers, servos, potentiometers, the DHT11 and DHT22, the HC-SR04, SSD1306 OLEDs, 16x2 LCDs (with or without I2C), relays, the 74HC595, the L298N, the DS18B20, the MPU6050, IR receivers, PIR sensors, light sensor modules, keypads, NeoPixels, rings and strips, TM1637 and MAX7219 displays and seven-segment displays.
- Wires follow the routes drawn in Cirkit.
- Code. A board's sketch comes across onto that board.
- Anything else becomes a pink note naming it, and the report lists it.
From GitHub
Full guide: GitHub to Mokxi, step by step, with an example that opens here.
Paste a link to a public repository, a folder in one, a single .ino file, or
a gist. A PlatformIO project or an Arduino sketch folder comes across with its
code and its libraries list. A link to a platformio.ini, or to a file in a
PlatformIO src/ folder, brings the whole project around it. Mokxi's server
fetches public projects from GitHub only, sends no sign-in of any kind, and
caps the size (10 MB for a repository, 2 MB for a file or a gist). For a
private repository, download the zip from GitHub and drop it instead.
From GitLab, Bitbucket and Codeberg
The same as GitHub: paste the link to a public repository, a folder in one or a
single sketch file on gitlab.com, bitbucket.org or codeberg.org. Mokxi
reads the site's own zip of the repository (10 MB at most) and opens the folder
you linked, or the file (2 MB at most). Private repositories need a sign-in,
which Mokxi never sends, so download the zip there and drop it instead.
From a paste site
Paste a link to one paste on pastebin.com, paste.ee, dpaste.org or hastebin.com.
Mokxi fetches its raw text and reads it the way it reads anything pasted: a
sketch, a diagram.json, a CircuitJS export. A paste the site keeps behind a
sign-in (hastebin.com asks for one now) cannot be read; copy its text and paste
that instead.
From Dropbox and Google Drive
A Dropbox file or folder link, and a Google Drive file link, work when anyone with the link can open them without signing in. A Dropbox folder comes as the zip Dropbox makes of it, and is read like a dropped zip. A Drive folder, a Google Doc, a file that asks you to sign in, and a file too big for Drive to scan for viruses cannot be read: Mokxi says so, and you can download the file and drop it instead. Files are capped at 2 MB, and zips at 10 MB.
From Instructables
Paste the project's address (instructables.com/<Project-Name>/). Mokxi
reads the page's attachment links and opens the .ino, .zip and .fzz
files attached to it, plus any .txt attachment that holds code. It reads only
instructables.com and its file host, and at most eight attachments, 8 MB in
all. A project with no file attached has nothing to read: copy the code from its
steps and paste it.
From Arduino Project Hub, Hackster and Arduino Cloud
Full guides: Arduino Project Hub, Hackster and Arduino Cloud, each with the steps and what the page reads.
Paste a project page's address (projecthub.arduino.cc/<user>/<project> or
hackster.io/<user>/<project>). Mokxi reads the code pasted into the page (its
Code section, and any block in the story that is a sketch), and the .ino,
.zip, .fzz, .h, .cpp and code .txt files attached to it. The first
sketch opens as <project>.ino; other code blocks become its tabs, and a
second whole sketch (pages often show two versions) is kept as a .txt tab.
Shell commands and parts tables are left out. When the page has no code of its
own but links to GitHub, Mokxi opens the GitHub project it links to instead.
The hardware the page lists comes across as a note in the report, not as parts:
place them yourself. Schematic and breadboard pictures, 3D print files and
videos do not come across. Mokxi reads only the page's own site and its file
host, at most eight files, 8 MB in all.
A shared Arduino Cloud sketch (an app.arduino.cc/sketches/<id> link, or a
create.arduino.cc/editor/.../preview link from Share Sketch) opens with its
code files, when its owner set it to Public, anyone with the link can view
the sketch. A private sketch cannot be read without a sign-in: download it
there (Download Sketch, which gives a zip) and drop the zip on the import
page.
From Fritzing
Full guide: Fritzing to Mokxi, step by step, with an example that opens here.
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; also diodes, capacitors and regulators of every package, DC jacks, a chip Mokxi has by its part number (an LM358, a 4N35, Fritzing's generic IC labeled 595), a bare ATmega168 or 328 (it runs as the Uno it is the heart of), and the simulator's sources, multimeter and oscilloscope.
- Stripboards. The copper strips, and the cuts in them, are joined by wires the same way a breadboard's strips are.
- Pin headers and test leads are connectors, not parts: they are left off, and the wires that met at them still meet.
- 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.
- Notes. Fritzing's notes become sticky notes.
- Parts from other libraries, and custom parts, become a pink note naming them.
From SimulIDE
Full guide: SimulIDE to Mokxi, step by step, with an example that opens here.
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
D13andA0); also 74xx and CD4000 chips, resistor arrays, LED bars, multi-digit displays, gates with more inputs (as a chain of two-input gates), probes, meters, the scope and the logic analyzer, the Nokia 5110, SSD1306 and ILI9341 displays, and a bare ATmega (as the Uno). SimulIDE powers its chips and displays without wires, so the import wires their power for them. - Code. SimulIDE keeps the sketch in its own editor and loads a compiled
.hexinto the board, and Mokxi builds from source, so put the.inoin the folder or zip with the circuit. The report says when only the.hexpath was there.
From KiCad
Full guide: KiCad to Mokxi, step by step, with an example that opens here.
Drop the schematic: a .kicad_sch (KiCad 6 and on), the .kicad_pro or a zip of the project folder (Mokxi opens the project's root schematic), or the .sch of KiCad 4 and 5. Copy and paste of the file's text works too.
- What is read. Every symbol, where it stands, how it is turned and mirrored, every wire and junction, labels, global labels and power symbols. Nets are made the way KiCad makes them: wire ends, pins and labels that meet are joined, a pin or label in the middle of a wire joins it, wires that only cross do not, and labels or power symbols of one name are one net. A chip's hidden power pins (such as a 74HC595's VCC and GND) join the net of their own name, as in KiCad.
- Parts. Arduino Uno, Nano and Mega, ESP32, ESP32-S3, ESP32-C3 and Pico modules, resistors, capacitors, inductors, LEDs and RGB LEDs, diodes and zeners, potentiometers, push buttons with two pins, slide switches with three, transistors and MOSFETs, buzzers, batteries, 74xx and CD4000 chips, the 555, op-amps, linear regulators (78xx, AMS1117), NeoPixels, and the common sensor and display modules by name. Two-pin parts keep the direction the schematic draws them in.
- Left as notes. A symbol Mokxi has no part like becomes a labeled note where it stood, and the report lists it with the connections it took with it. A part is mapped only when it really is that part: a TVS diode array is not a diode, an AC motor is not a DC motor, a four-pin switch or an SPST switch is not Mokxi's switch, and a connector labeled "OLED" is still a pin header. Pin headers, test points and mounting holes are where cables connect, so they are left out and named in the report.
- Sheets inside sheets. A sub-sheet whose file comes with the upload, and that is used once, is read and joined by its hierarchical labels and the sheet pins on its parent. A sub-sheet that is missing from the upload, or used more than once, is left out and named in the report.
- Older files. A
.schfrom KiCad 4 or 5 does not carry its symbols, so their pins are found in the-cache.libor.libthat comes with it. Add it to the upload. Without it, the parts are notes and the report says why; no pin is guessed. - Code. A schematic has none. Add the
.inoto the upload and it goes onto the board. - Not read. Buses (bus wires, bus entries and labels like
D[0..7]), the board layout (.kicad_pcb), simulation models and symbols marked do not populate. - Positions. Parts keep their relative places on the sheet. Wires are laid out with Tidy as the project opens (up to 30 wires); a bigger schematic has straight wires, pin to pin, until you press Tidy wires.
From EasyEDA
Full guide: EasyEDA to Mokxi, step by step, with an example that opens here.
Open the schematic in the EasyEDA Standard editor, choose File, then Export,
then EasyEDA Source, and drop the .json file here (or paste its text). A
link to an EasyEDA or OSHWLab project is not downloaded: Mokxi tells you
these steps instead. EasyEDA Pro projects (.epro) are a different format
and are not read yet. Files over 1 MB are skipped, so export just the
schematic when a project is large.
- What is read. Every part with its designator, value, package and pins; the wires; junctions; net labels; and power and ground flags. An EasyEDA source file has no netlist, so Mokxi finds the connections the way the editor draws them: a wire joins everything along it, and labels and flags with the same name are one connection, on every sheet. Sheets are laid out side by side.
- Parts. Resistors, capacitors, inductors, LEDs, diodes, transistors, switches, potentiometers, common modules and 74xx and CD4000 chips, and Arduino-type boards, by their designator, value, package and pin names (the same table the KiCad and SPICE readers use). A part Mokxi has no part for becomes a pink note naming it, and the report lists it.
- Pins. A pin that Mokxi's part has no match for is listed in the report and left unconnected, never guessed.
- Not read. The board (PCB) in the same project, drawings and text on the sheet, and part libraries. A frame or logo with no pins is left off.
- Code. A schematic has no code. Add the
.inoto the upload and it goes on the board.
From Qucs and gEDA
Full guides: Qucs and gEDA and Lepton EDA, each with an example schematic that opens here.
Drop the schematic, a .sch file. Mokxi reads what is inside to tell which
tool saved it: Qucs (and Qucs-S and QucsStudio, which save the same way) or
gEDA gschem (and Lepton EDA, which carries gEDA on). You can also paste the
file's text into the box.
- Parts. Resistors, capacitors, inductors, diodes and zeners, BJTs (NPN
and PNP), MOSFETs, ground, DC voltage sources and sine sources, from both
tools; from gEDA also LEDs, batteries, potentiometers, push buttons and
supply symbols (
Vcc,+5V,+3.3V). Anything else becomes a sticky note with its name, and the report lists it. - Pins and nets. Neither file says where a part's pins are: Qucs keeps
them in its program and gEDA in each symbol's
.symfile. Mokxi knows the pins of the stock parts above, and works out where each one stands as the part is turned and mirrored. Wires and nets that meet join, Qucs wire labels and gEDA net names with the same name are one net, and gEDA supply symbols are named nets. A gEDA symbol embedded in the schematic carries its own pins, so it is read too. - Left out. Simulation blocks (
.DC,.TR), equations, diagrams, SPICE directives and models, title blocks and drawings: Mokxi runs the circuit itself, so put a probe, meter or scope where you want to watch. A value Qucs takes from a variable (R = Rload) gets Mokxi's default, and the report says which. - KiCad. A KiCad
.schis a different format: see From KiCad above.
From Falstad CircuitJS
Full guide: Falstad CircuitJS to Mokxi, step by step, with an example that opens here.
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, logic gates (more than two inputs become a chain of two-input gates), inverters, logic inputs and outputs, D and JK flip-flops, counters, multiplexers and analog switches (as 74HC and CD4000 chips with their supply), relays, lamps, seven-segment and number displays, 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
Full guide: Tinkercad to Mokxi, step by step, with an example that opens here.
Tinkercad Circuits can export a circuit as a board file, which holds every part and every wire. With its code beside it, the whole project comes across, wired:
- The circuit. Open the circuit in Tinkercad, press Export and
download the
.brdfile. - The code. Open Code, switch to Text, and press the download
button to save the
.ino(or select all of it and copy it). - Drop both on the import page or onto the editor, together.
Mokxi places every part it has where it stood: the Uno and the micro:bit, LEDs with their color, RGB LEDs, resistors and potentiometers with their value, buttons, slide and DIP switches, piezos, servos, DC and gear motors, the TMP36, photoresistors and phototransistors, the HC-SR04, PIR, IR receiver, soil, force and gas sensors, the 4x4 keypad, 16x2 and I2C LCDs, seven-segment displays, NeoPixels, transistors, diodes, capacitors, the 9 V battery and power supply, relays, the 7805, the L293D, the LM741, the 555, 74HC chips and the CD4511. Each is wired as Tinkercad had it, and the code goes on the board. The breadboard is not brought across: its strips are already in the wiring. A part Mokxi does not have (a Parallax PING sensor, for one) is a note naming it, and the report lists it.
The board file has no code and no settings such as a power supply's voltage (set to 5 V) or an I2C address, so the report says so when they matter.
No .brd? Copy the Component List table (or download it as CSV), paste
it in the import box with the code below it, or drop the .csv and .ino
together. The parts arrive in rows with their values, for you to wire.
Mokxi never reads Tinkercad's pages: a Tinkercad link needs a sign-in, so the import page says how to export instead.
From PlatformIO
Full guide: PlatformIO to Mokxi, step by step, with an example that opens here.
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:...]), itsboardread the same way the PlatformIO export writes it, and you can pick another. - The code.
src/main.cppbecomes the board'ssketch.ino(its#include <Arduino.h>and declarations work as they are), and the other files insrc/andinclude/come beside it. Files in folders insidesrc/do not, since a Mokxi project has no folders. - Libraries. Each
lib_depsentry is checked like a Wokwilibraries.txtline, and the project's own libraries inlib/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
Full guide: Open an .ino file online, with the board guess, the wiring Mokxi adds and an example sketch.
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.
When the sketch folder has a sketch.yaml (the Arduino IDE 2 and
arduino-cli) or a sketch.json (an Arduino Cloud download), its board comes
from there, and its libraries are checked, along with each library's own
depends= line in a libraries/ folder. An Arduino Cloud sketch's
thingProperties.h is kept, but a simulated board cannot reach Arduino IoT
Cloud, so its cloud variables keep their starting values.
Otherwise 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.
A sketch comes without a circuit, so Mokxi wires one from what the code says: the libraries it includes (Servo, DHT, LiquidCrystal_I2C, Adafruit_SSD1306, Adafruit_NeoPixel and others) and the pins it sets up and uses. An LED gets its 220 ohm resistor. The summary says what was wired, such as "We wired: servo on 9, LED on 13 (with 220 ohm)"; move or rewire anything that differs from your circuit. When the code says nothing about what is wired, the project starts with just the board, ready for you to wire. To answer somebody's forum post with their code fixed and running, use mokxi.com/fix (see Help someone fix their code).
From a compiled .hex file
Drop a compiled program, the .hex file the Arduino IDE saves with
Sketch, Export Compiled Binary, or one somebody sent you, and it runs
as it is: the project opens with the board alone, running that program as the
one uploaded in its Firmware panel. It starts on the
Uno, or on the Mega 2560 when the program is too big for an Uno. A .hex does
not say which board it was built for, so pick the right one from the Board
list before opening: the list offers the AVR boards whose flash holds it (Uno,
Nano, Mega 2560, Leonardo, Pro Mini and ATtiny85). When the Arduino IDE saved
two, the one without with_bootloader in its name is used.
A compiled program has no code to edit. Wire parts to its pins as usual; to change what it does, import the sketch it was built from instead.
A Mokxi link
A Mokxi link pasted into the import box, such as mokxi.com/p/... or a
shared editor link from app.mokxi.com, is already a Mokxi project, so there
is nothing to import: the box says so and opens it.
Pasting
The import box reads what chat assistants and forums paste: code inside
Markdown fences (```), a Wokwi diagram.json and its sketch in two
blocks of one reply, and a project with words around it. A link to a site
Mokxi cannot read says where that site keeps the project and how to bring it
over (a Drive folder, a OneDrive or Mega link, a YouTube video).
A photo or a screenshot
Mokxi cannot read a picture of a circuit itself. Drop one and the import offers Copy photo prompt: give that prompt and the picture to ChatGPT, Claude or Gemini, and paste its answer here. It writes the circuit in Mokxi's AI project format and lists what it had to guess.
From LTspice
Full guide: LTspice to Mokxi, step by step, with an example that opens here.
Drop the schematic (.asc) on the import page or onto the editor, or paste
its text. LTspice stores where each symbol stands and where each wire runs,
not which pins are joined, so Mokxi works the nets out the way LTspice does: a
pin, a wire end or a flag on the same point is one node, a wire end that lands
on another wire joins it, wires that only cross do not, and flags with the same
name are one net. A flag named 0 is ground, and each one becomes a ground
part.
What comes across: resistors, capacitors (also polarized), inductors, diodes
(also Schottky and zener), LEDs, NPN and PNP transistors, N and P channel
MOSFETs, DC voltage sources (as a floating source), sine and pulse sources
(as a generator, when the source's minus pin is on ground), and the
five-pin op-amps (UniversalOpamp2, opamp2) when their negative supply pin
is ground. A model name is kept when Mokxi has that exact part (2N3904,
1N4007, IRLZ44N; a gain group such as BC337-40 is its part), otherwise
the part is Mokxi's default of its kind and the report says so. A .param
line is used to fill in a {name} in a value. Comments become sticky notes.
The simulation commands (.tran, .op, .ac, .step and the rest) are read
into the report's notes. Mokxi runs live, so press Run and watch the nodes
with a scope or a meter; a frequency or DC sweep is not carried.
What does not come across, each as a pink note that names it: current sources,
behavioral sources, PWL and other special sources, a sine or pulse whose minus
pin is not on ground, an op-amp on a negative supply, every symbol that is not
one of the standard ones above (ICs, switches, transmission lines,
subcircuits), since their pin positions are in the symbol file LTspice keeps
and not in the schematic. Model cards and libraries (.model, .lib) are not
imported. LTspice itself is not needed, and nothing in the file is run.
A SPICE netlist LTspice exports (View > SPICE Netlist, a .net, or a
.cir) opens as a netlist, as in the next section.
From Proteus, Multisim and CircuitMaker
Proteus, Multisim and CircuitMaker keep designs in their own closed formats,
which only they can open. From Multisim, choose Transfer, then Export
Netlist; from CircuitMaker, choose File, then Export, then SPICE Netlist.
Open the .cir with Save â–¾ > Open JSON or SPICE. From Proteus, take a
screenshot and use the photo prompt. An LTspice netlist
(.net, from View > SPICE Netlist) opens the same way as any SPICE deck, and an
LTspice schematic (.asc) is imported directly (see From LTspice).
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.handDHT.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, on every plan. See plans.
Taking a project out again
Nothing locks a project in. The Export button in the editor header 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.
Related
- Coming from Wokwi: each Wokwi idea beside its name in Mokxi.
- Help someone fix their code: a forum sketch, wired and running, with a reply to paste.
- SPICE netlists and custom chips.