What’s new
Release notes from the apps in the kevsrobots suite, newest first.
-
ProjectsYour builds, steps and parts lists
-
Snakie by kevsrobotsWrite and run MicroPython, in your browser or on your desktop
-
BetterCAD by kevsrobotsFree CAD for designing parts to 3D print
-
Snakie by kevsrobots
Snakie v0.91.0
Added
RangeFinderjoins the bundled HC-SR04 driver (hcsr041.1.0). The standalonerange_finder.pythat circulates with HC-SR04 projects is now part of the installablehcsr04module, as aRangeFinderclass alongsideHCSR04: positionaltrigger_pin/echo_pinarguments,distanceanddistance_cmas properties, andduration/distance_to_objectrecorded on each read. Unlike the loose copy it replaces it inherits this driver’s echo timeout, so a missing or out-of-range target returns-1instead of busy-waiting on the echo pin forever. Installing the HC-SR04 module from the Modules manager now covers both styles of script; existing boards will be offered the 1.1.0 update.- “What block is this?” (#1245). A drop zone in the bottom-left corner of the blocks canvas. Drag any block onto it — including one from a program somebody else wrote — and it says what the block is: its shape and what that shape means, the drawer it lives in, whether it came from Snakie’s palette, a part, a plugin or an imported module, the Python library it imports, the pin it claims and which way it drives it, what is plugged into each socket, and the Python that one block writes. The block springs straight back to where it was, so asking about a program never edits it, and a block this build has no description for says exactly that instead of guessing. Blocks with a help article offer a Read more about this button straight into the in-app help.
-
Detect the modules baked into a board’s firmware (#1246). Snakie could only ever see two kinds of module: the ones in its own catalog, and the
.pyfiles sitting in/and/lib. A vendor MicroPython image compiles modules INTO the binary — an Arduino Alvik’s carriesarduino_alvik,ucPackand a frozenmodulino— and none of them are files, so the Detected panel listed nothing and the learner was left with an import that works and an app that says the module isn’t there. A new discovery probe asks the board to enumerate itself:help('modules')for everything built in or frozen, a walk ofsys.pathfor the files (whichhelp('modules')deliberately doesn’t scan), andsys.modulesfor whatever is already live. The Detected shelf grows a Built into the firmware section, labelled with the board’s own description, and expanding a row runsdir()on that one module — the only way to see inside something with no source file, and honest about what freezing discards: names only, no signatures. Nothing is imported to build the list, because importing a whole firmware’s worth of modules is how an ESP32 runs out of memory. -
A catalog module the firmware already provides now reads BUILT IN (#1246). It imports, so the old probe called it installed and offered an UPDATE for something with no
/libcopy to update and nothing Snakie could replace. A/libcopy that shadows the frozen one still reads as an ordinary install, because that copy is the one that actually imports. -
Function settings, in one place (#1218, epic #1206). A
defor method block’s right-click menu has a new Function settings… dialog holding both of the things written around a function that are text rather than sockets: its decorators (#1215), which had no editing UI at all, and its extra parameters (#1134) — a default, a*args, a**kwargs— which were only reachable through a hidden row on the block. Decorators can be added, typed, reordered and removed, with@property,@staticmethod,@classmethodand@micropython.nativeoffered as one-click entries. The old Add extra parameters… item stays as a shortcut into the same dialog, focused on the extras box. The generated Python is unchanged — only where the text is edited has moved — and the parameter list itself stays on Blockly’s own cog, because renaming a parameter there renames it in every call. self.xandobj.xare blocks of their own (#1223, epic #1206). Reading and changing something an object remembers used to open as the grey Python escape hatch — the second-biggest theme in the corpus, sitting in the drawer for the Python the palette does not model. Four new advanced blocks claim it: self . speed and set self . speed to …, which have theselfdecision built in and no socket to unplug, and ( ) . speed / set ( ) . speed to … for any other object. Files open with them automatically; method calls (self.led.on()) and deeper targets (self.motor.speed) are unchanged.-
Advanced blocks in a simple-mode file are offered, never removed (#1212, epic #1206). Opening a file that uses advanced blocks while the advanced drawers are off now shows one dismissable line — “This file uses advanced blocks — show them in the toolbox?” — with a Show them button that flips the setting, and a caret that names the blocks. It appears once per file open, not on every edit. Nothing about the file changes either way: the reader takes no notice of the level, so the same Python becomes the same blocks in both tiers, they render, drag, duplicate and generate normally on the canvas, and no line is quietly downgraded to a grey Python block because of a preference. The level decides what is in the drawer and nothing else.
- Courses can ask for the blocks they need (#1214, epic #1206). A lesson —
or a whole course — can now declare
level: advancedin itscourse.yml, and opening it switches Advanced blocks on, with a one-line note in the Learn panel saying so and where to switch them off again. Leaving the lesson does not put the drawers away: the learner has now seen them. The blocks track’s “When the block you need doesn’t exist yet” lesson carries the key, so the grey Python blocks it teaches are in the toolbox even for a learner who started in simple mode. A course that declares nothing never turns advanced
…
-
Snakie by kevsrobots
Snakie v0.85.4
What’s Changed
- Cut the 0.84.1 release by @kevinmcaleer in https://github.com/kevinmcaleer/Snakie/pull/1184
- Add a 400-point breadboard part to the Standard library by @kevinmcaleer in https://github.com/kevinmcaleer/Snakie/pull/1185
- Blocks: zoom to fit centres the blocks in the canvas by @kevinmcaleer in https://github.com/kevinmcaleer/Snakie/pull/1186
- PDF export: draw parts whose library id no longer matches, instead of “part library not installed” by @kevinmcaleer in https://github.com/kevinmcaleer/Snakie/pull/1187
- Save the active file on Cmd/Ctrl+S from anywhere in the window by @kevinmcaleer in https://github.com/kevinmcaleer/Snakie/pull/1188
- Add a 3-D model to the Yellow TT Motor part by @kevinmcaleer in https://github.com/kevinmcaleer/Snakie/pull/1189
- Lay the TT motor mesh flat and give the part its real footprint by @kevinmcaleer in https://github.com/kevinmcaleer/Snakie/pull/1190
Full Changelog: https://github.com/kevinmcaleer/Snakie/compare/v0.84.1…v0.85.4
-
Snakie by kevsrobots
Snakie v0.84.1
Changed
- New canvases default to the
scratchblock shape. Settings ▸ Appearance still offersstandardandclassic, and an existing choice in storage is unaffected — this only changes what a first-run canvas looks like, from Blockly’s compactstandardrow layout to the taller, Scratch/MakeCode-style pill blocks newcomers are more likely to recognise.
Fixed
- Blocks never overlap, and the functions use the width of the canvas.
Open a converted
.pyand its functions, classes and main program could land on top of each other. The canvas measured each stack straight after loading it, but Blockly draws on the next animation frame, so every stack measured 0px tall and they were laid one gutter apart. The layout now flushes Blockly’s render queue before it measures, so each island of blocks gets a box of its true size and no two boxes share a pixel. The functions no longer trail down a single column, either: they flow into as many columns beside the main program as the viewport is wide, each column as tall as the program (or the screen, for a short program) before the next one opens. A file whose layout the learner arranged keeps that layout, but not its overlaps — a stack that has grown into the one below it moves the lower one down, on opening and after each edit, with the stack being edited staying where it is. The PDF export’s off-screen blocks get the same layout. - Run on the web simulator shows the program’s output while it runs. Click
Run on a blink program —
while True:aroundtime.sleep(1)and aprint('hello')— and the console stayed empty: nohello, ever, until Stop. The program was running; its output was not leaving the simulator’s worker. The worker posted output to the page on a timer, andtime.sleepin the WebAssembly port is a busy-wait inside the interpreter, so a program that never returns never let the timer fire. The desktop simulator had learned this already and posted each line as it was printed; the web one had not. Both workers now share one output pump that posts a line the moment it is complete, sohelloappears once a second, on the web as on the desktop. - The PDF export always includes the blocks. The blocks pages read the Blockly canvas on screen and nothing else, and that canvas only exists while the Blocks view is open. Press the print button from the Code workspace, from Electronics or Build, or with the split collapsed to its Python-only view, and the document went out with every other section in it and no blocks — and nothing said so. The export now photographs the canvas on screen when there is one, and otherwise builds the active file’s blocks into an off-screen workspace (the same footer-or-derived reading the Blocks view opens on, in the same theme and renderer), prints them, and throws it away. A file whose blocks this build cannot read is reported as “exported without the blocks” in the status bar rather than quietly dropped.
Added
-
The functions get a column of their own, and nothing is drawn on top of anything. Opening a MicroPython file in Blocks or Split laid every top-level stack out in one tall column — so a file that defines four functions opened with its program a screen and a half below the last of them, and you scrolled past everything to find where it starts. Worse, the column was spaced by an ESTIMATE: the converter is pure and has never loaded Blockly, so it counted rows and multiplied by numbers somebody had read off a screenshot. When the estimate came in short — which a
deffull of arithmetic reliably did — the next stack was drawn straight over the one above it.Now the program runs down the left and the functions and methods stand beside it in a second column, each clear of the one above, and the sizes are MEASURED rather than guessed: the canvas asks each stack how big it actually rendered. A layout you arranged yourself is still yours — a file whose footer matched its code opens exactly as you left it, and a stack you drag aside stays where you put it even as the code pane keeps re-converting around it.
-
Settings ▸ Appearance ▸ Block shape — try all three Blockly geometries. Blockly ships three renderers and they are three vocabularies rather than three settings of one dial, so which one suits a room is not a question the app can answer on its own: a class arriving from Scratch wants the pills and the hexagons, and somebody reading a forty-line robot file wants the compact rows.
Standard is
thrasos, the flat standard rows, and the default. Classic isgeras, Blockly’s own default, the same geometry with a bevelled edge. Scratch iszelos, thescratch-blocksport — pill reporters, hexagonal booleans, roughly twice as tall. All three wear the same Soft Shell palette, fonts and per-category lettering, so the choice is a SHAPE and nothing else, and all three are stock: the hand-tuning that made the old canvas fragile is not coming back on any of them.An open canvas redraws as soon as you pick one. Blockly fixes its renderer when a workspace is created and offers no setter, so this is the one appearance setting that re-injects the canvas rather than restyling it — your file, your scroll position and your arrangement come straight back. The printed PDF follows the same setting, so a page matches the screen it was printed from.
-
A PWM can be named with its frequency:
name PWM on pin [GP15 ▾] as [motor_a] at [1000] Hz.pwm_motor_a = PWM(motor_a, freq=1000)is how nearly every robot tutorial opens, and it matched nothing this palette writes — sopwm_motor_awas not a name the blocks knew, and everypwm_motor_a.duty_u16(int(50 * 65535 / 100))under it came back as the generic *call duty_u16 on (pwm_motor_a) with (turn (50 × 65535 ÷ 100) into a
…
- New canvases default to the
-
Snakie by kevsrobots
Snakie v0.68.8
Added
-
A Modules drawer, filled from your program’s own imports (#1048, epic #1007). Open a real driver program and it converts perfectly — ten blocks, no warnings, byte-exact round trip — and offers you nothing: the
oled.text(…)lines are raw Python blocks you can drag but cannot author more of. That is the right floor and a poor ceiling.There is now a Modules category, one sub-drawer per module the program imports, separate from My parts — which keeps meaning “things on your breadboard”, because that distinction earns its keep.
This first tier is the one the issue calls a free win: the curated symbol tables already carried kinds and one-line details for ~39 modules and were wired only to Monaco’s completions. Nothing in the blocks stack had ever imported them. So
machine,time,neopixeland friends get blocks with no parsing, no file and no board — which matters because those are exactly the modules whose source we will never have: they are frozen into the firmware. Thedetaillines turn out to be signatures, so the blocks get real parameter names too. Member-level dialect scope is respected, so a CircuitPython board is not offeredtime.sleep_ms.Three tiers now fill the drawer, best first, and a module answered by one is never asked of the next:
- Its own source, wherever the nearest copy is — your project folder, then
the board’s
/lib, then the drivers Snakie bundles.module-api.tsreads the classes, methods, parameters and defaults out of the.pywith #1019’s lexer: parsing only, never importing, because a module a learner downloaded is somebody else’s code and importing it on the host to look inside would run it. Real parameter names, real defaults, and a socket only for the arguments that have no default. - The curated tables, as above.
- The board’s own
dir()— one batched round trip for the modules nothing else could describe (a C module, a stripped.mpy), and only for those. This tier imports on the board, which is the same exposure as pressing Run.
Reading a module’s source also retires a guess that has been visible on the face of every derived part block since #1017.
vl53l0x→VL53L0Xis right for most drivers and plainly wrong for the rest; a wired part whose driver we can find now carries the class the driver actually declares — the Grove I²C motor driver saysGroveMotorDriver, notTB6612. The field stays editable, and a part whose driver is nowhere keeps the old guess. - Its own source, wherever the nearest copy is — your project folder, then
the board’s
-
The hardware blocks speak CircuitPython (#1040, epic #1007 and epic #209). The same block, on a Feather, writes
digitalio.DigitalInOut(board.GP15)instead ofLed(pin=Pin(15, Pin.OUT))— one block, two templates, which is the decision #1040 left open anddocs/blockly-epic.md§9.7b now records.The argument in one line: a learner’s program should be a program, not a program-for-a-Pico. Two block sets would have thrown away the portability the
.py-with-a-footer format exists for; with one block a canvas built in a classroom’s MicroPython half opens and runs in its CircuitPython half. The objection — a block whose code you cannot predict — is answered by the mirror next door, which shows exactly what it generated.Nine of the twelve hardware blocks do it. Servo and buzzer have no CircuitPython core equivalent (they want
adafruit_motorandsimpleio, third-party libraries and a different promise), so the toolbox withholds them there — and scope is now derived from what a block can generate, so a working block can never be hidden from the board it works on.Pin names come off the board’s own silk label, which is what CircuitPython’s
boardmodule is built from:board.GP15on an RP2040,board.IO15on an ESP32-S3. -
Hardware lines come back as hardware blocks (#1058, epic #1007). Only the turtle palette declared
read, so a hardware program converted asymmetrically: blocks → Python perfect, Python → blocks dropping to a raw block on exactly the lines that mattered.led_15.set(True)was a grey box of text; the learner could read their program but not build it.A hardware block doesn’t write one line — it writes a constructor hoisted into the setup section and a call on it, with the pin in the object’s name. Reading one back means reading both lines and then not emitting the constructor a second time. Eight of the twelve hardware blocks now do: LED on/off and toggle, pin write and read, PWM frequency, servo angle, and the buzzer’s tone and stop. A pull resistor is read out of the constructor, which is the only place it appears.
All or nothing per object. If any use of a hoisted object can’t be read, none of them are and its constructor stays — otherwise you get two
Leds driving one pin, the learner’s and the block’s own hoisted copy. And a constructor that isn’t character-for-character what the block would have written is somebody else’s line, and is left alone.The four left out say why in the code: the onboard LED has no pin in its name, “button is pressed” changes the shape of its line with the dropdown, and the PWM-duty and ADC blocks wrap theirs in arithmetic that is the lesson. Those still convert to raw blocks, exactly as before.
-
An I²C bus, as a block (#1057, epic #1007). Wiring an I²C sensor is one of the first things anyone does on a Pico, and there was no block for it — not I²C, not SPI. So
i2c = I2C(Pin(0), Pin(1))andprint(i2c.scan())came back from the Python converter as two raw-Python blocks: a program you could read and could not build.Hardware now has “the I²C devices on SDA / SCL”, handing back the addresses as a list, and “is there a device at address … on SDA / SCL”, which is the question a wiring problem actually asks and drops straight into
…
-
-
Snakie by kevsrobots
Snakie v0.56.0
Added
-
Compile to
.mpyin the browser (#970). On app.snakie.org the file tree’s context menu read “Compile to .mpy (unavailable)”, greyed out. Nothing was stopping it:mpy-crossis already WebAssembly, and a browser tab runs WebAssembly perfectly well — it had simply only ever been wired to the desktop app’s main process. It now works in both, from the same menu item.The compiler is built twice from the same objects and ships one
.wasm: a CommonJS loader for node (.cjs, because this package is"type": "module"and a.jswould parse as ESM and handrequire()an empty object) and an ES module for the browser (-sENVIRONMENT=web,worker, which also links Emscripten’srequire("node:fs")branches out entirely). A test compiles the same source through both loaders and fails if the bytecode differs by a byte — a student’s.mpymust not depend on which app they used.It runs in a worker. A compile is short, but it is a synchronous WASM run with no yield the browser could paint between; the simulator learned that the expensive way. The
.wasmis a static asset of the web bundle, fetched once and handed in aswasmBinary(so nothing has to guess at a hashed asset path), and it is precached by the service worker — so compiling works offline after the first visit.Only the two ends differ between the platforms now: where the module is loaded from, and where the file comes from and goes. The run in between — Emscripten’s in-memory filesystem, the callbacks, the wording of a syntax error — is one shared module both call, so a fix to it reaches both. On the web the file ends are the web filesystem (a real folder via the File System Access API, or the OPFS
Projects/folder on an iPad), and the.mpygoes out through the bytes channel, never the text one, which would UTF-8 mangle every byte above 0x7F.
Fixed
-
The browser build picks up a new deploy on its own (#971). app.snakie.org could keep serving an older build until you hard-reloaded the tab. Not HTTP caching — the service worker (#464), and two halves of one mistake.
registerType: 'autoUpdate'was silently inert. vite-plugin-pwa only turns it intoskipWaiting+clientsClaimwheninjectRegisteris'auto'or absent, and we set'script'— chosen so the registration wasn’t an inline script the strict CSP rejects. So Workbox shipped a worker that callsskipWaiting()only when the page posts it aSKIP_WAITINGmessage, and never callsclients.claim(). Nothing ever posted that message, because the registration the plugin injected was a barenavigator.serviceWorker.register(…)with no update handling at all.A new deploy therefore installed and then sat in
waitinguntil every tab of the origin closed — which, for the tab you keep the IDE open in, is never — while each navigation kept being answered from the old precache. A hard reload worked because it is the one thing that bypasses the worker. The config read as if it auto-updated; the build disagreed, with no warning.Both flags are now set explicitly, so the behaviour can’t hinge on a plugin inference again, and the app registers the worker itself — our bundle is
'self', so the CSP reason forinjectRegister: 'script'still holds without its side effect.When a new build lands the page reloads itself — but only when nothing is unsaved. Snakie is an editor, and reloading over an unsaved buffer would be a worse bug than the stale build. With work in progress it says so instead, through the same notifier the desktop app uses, and waits for you; the notice says reload, not restart, because a browser tab has no restart. The check assumes there IS unsaved work until the UI says otherwise — a needless prompt is an annoyance, a discarded buffer is not.
A
version.jsonstamp ships beside the bundle and is fetchedno-store, so the staleness check can’t itself be answered from a cache. It names the new version in the notice, and covers contexts with no service worker at all. -
macOS releases no longer fail at random (#968). Signing died with
security set-key-partition-list … SecKeychainUnlock: The user name or passphrase you entered is not correct— v0.51.1 and v0.55.0 each needed three attempts. It is a defect in electron-builder’s own keychain setup:importCertspasses the .p12’s password toset-key-partition-list -k, which wants the keychain’s.securityonly consults-kwhen it has to unlock the keychain, so the wrong password is invisible while the keychain happens to still be unlocked and fatal once anything has relocked it — a latent bug that shows up as a coin toss.release.ymlnow builds and unlocks the signing keychain itself, imports the certificate with the right password in each place, asserts the identity landed, and hands electron-builder the keychain viaCSC_KEYCHAIN. WithCSC_LINKabsent, electron-builder skips its own keychain code entirely, so the broken path is never taken. Unsigned builds (a fork, secrets unset) are unaffected — the step is a no-op without a certificate. Background indocs/macos-signing.md.Failures here were also silent: the tag pushed, master claimed a release, and no release existed. The identity check now fails in seconds with a clear message rather than twenty minutes in.
-
The Cancel button is readable in the Simulated device memory dialog (#969). It was near-white at rest and pure white on hover, over the dialog’s light card.
ConnectionControlrenders the dialog inline, so it is a DOM descendant of.conn-control— and the shell header’s chip rules, whose colours are chosen for a dark green bar, reached it through a descendant combinator and painted a modal button as if it sat on the header. Every real header control is a direct child, so
…
-
-
Snakie by kevsrobots
Snakie v0.55.0
Added
-
File sizes in both file trees (#955). Neither the local nor the device tree showed how big a file was, which hid the one case worth seeing: a 0-byte file looks exactly like a good one. This repo has met that — a truncated
lsm6dsox.pyon a board threw aSyntaxErrorat line 159 and cost real diagnosis time, which is what #864’s atomic writes exist to prevent.Sizes read as
0 B,847 B,2 KB,1.4 MB,1 TB— plain bytes below a kilobyte, deliberately. The app’s other formatter renders a 213-byte file as0.2 KBand an empty one as0 KB, which is exactly the reading this exists to replace.An unknown size shows nothing, never
0 B. Astatcan fail — a broken symlink, a file deleted between the listing and the stat — and a zero invented there would manufacture the very problem the column was added to reveal. Folders show nothing too: a folder is not an empty file.The device tree had the number all along (
os.ilistdirreturns it); it was simply never displayed. The local listing now stats each file, in parallel, and a failure leaves the size absent rather than failing the listing. -
The status bar keeps a history (#953). It shows one line at a time and every message wipes the one before it, so anything you were not looking at was simply gone — including the ones that matter afterwards: which file failed to sync, what the compile said, why an install stopped.
Click the message to see the recent ones; Show all opens the full log, where it can be copied to the clipboard, saved as a text file, or cleared. Settings ▸ Editor carries the three questions worth asking: keep a history at all, how many lines, and clear what is there.
Newest first on screen, oldest first in the file — the thing you just missed is the thing you clicked for, while a saved log is read by other tools and by scrolling down, and those want time running forwards.
Messages are recorded from the
snakie:statusevent rather than fromshowStatus, so a plugin posting to the bar directly is kept too, and the listener attaches at module load rather than from a component — the panel that reads the history is opened after the message you wanted. The cap is a ring buffer, applied to what is already stored as well as to what arrives, so lowering it in Settings takes effect immediately rather than drifting until enough new messages reconcile the two numbers. Turning history off discards what was kept, because a switch that says “don’t keep a history” and leaves the old one on disk is not telling the truth. -
Right-click a
.pyand compile it to.mpy(#949). MicroPython’s ownmpy-crossturns a source file into the bytecode container a board imports without ever seeing the source — smaller, and faster to import. It is now a context-menu item in the Files tree, writing the.mpybeside its.py, with the compiler’s own diagnostics when it fails:SyntaxErrorwith the line, not a shrug. -
We build the compiler ourselves (#950). The published
@pybricks/mpy-cross-v6works, but it is pinned to MicroPython v1.19 because its Makefile lists everypy/*.cfile by hand — ~108 of them, where v1.29 has 133.scripts/build-mpy-cross.shhas no such list: it pointsPROGat a.jsand lets MicroPython’s ownpy.mkcompute the sources, so the build tracks whatever the pinned tag needs and moving to a new MicroPython is one line. A test asserts the compiler is built from the same release the Board Finder offers firmware for, because a compiler older than the firmware we hand people is exactly the drift worth not having.It ships as WebAssembly: no per-platform binaries, and no third executable to sign and notarize inside the app bundle. It runs in the main process, which keeps 334 KB of
.wasmout of the renderer and away from the asset-path problem #947 was. And there is no third-party JavaScript in it either — the published package bakes its filesystem wiring into the artifact with--pre-js, where ours passespreRun/print/printErr/onExitfrom our own typed code. What ships ismpy-crossand nothing else.Three things cost real time and are written down where they bit:
emmakerewritesCC=gccintoemgcc, which does not exist; modern Emscripten pruneswasmBinaryfrom the incoming module API unless it is declared; and the loader must be named.cjs, because this package is"type": "module"and a.jsis parsed as ESM, so Emscripten’s CommonJS export never runs andrequirehands back an empty object — the same trap that makes the preloadindex.cjs.
Changed
-
The docs describe the app that ships (#962). The README announced “v0.13.0 released” at v0.54.x, and
docs/micropython-boards.mdclaimed 219 boards from a July snapshot while the shipped index held 225 from MicroPython v1.29.0. Nothing from this run of releases appeared anywhere: not the Board Finder, not the File / Device / Tools menus, not the shortcut sheet, not.py→.mpy, not the status history, not file sizes.The board catalogue is generated now, by
scripts/build-boards-doc.mjsfrom the same index the app ships, and a test holds its total, its MicroPython release and every one of its rows to that source. It drifted because it had to be retyped, and a reference that is quietly wrong is worse than none — the reader trusts it.The README’s Status section no longer names a version at all. A number there has to be maintained to stay true, and Releases already has it; what belongs in a README is what the app does.
No screenshots were audited: the repository contains none. Any that exist live outside it, and are still worth a pass against the current UI.
Fixed
- **Copying a
.mpyto the board no longer produces a 0-byte file — and ⌘S no
…
-
BetterCAD by kevsrobots hasn’t published a release yet. Follow it on GitHub.
Did you find this content useful?
If you found this high quality content useful please consider supporting my work, so I can continue to create more content for you.
I give away all my content for free: Weekly video content on YouTube, 3d Printable designs, Programs and Code, Reviews and Project write-ups, but 98% of visitors don't give back, they simply read/watch, download and go. If everyone who reads or watches my content, who likes it, helps fund it just a little, my future would be more secure for years to come. A price of a cup of coffee is all I ask.
There are a couple of ways you can support my work financially:
If you can't afford to provide any financial support, you can also help me grow my influence by doing the following:
Thank you again for your support and helping me grow my hobby into a business I can sustain.
- Kevin McAleer
Comments