DEV Community: 코딩나우(하늘아래)

Converting WebP to JPG on Windows with no dependencies (and the alpha channel gotcha)

코딩나우(하늘아래) — Wed, 23 Sep 2026 01:53:39 +0000

Someone sends you a folder of .webp files and the upload form only takes JPG. You don't need ImageMagick for this: Windows has shipped a WebP decoder since 1809 (as the Store-delivered Microsoft.WebpImageExtension), and WIC exposes it to PowerShell. But the built-in path has two sharp edges I only found by testing them.

First: renaming is not converting

$ head -c 16 photo.webp | xxd
00000000: 5249 4646 4e0a 0000 5745 4250 5650 3820  RIFF....WEBPVP8

Rename it to photo.jpg and those bytes don't change. Most viewers sniff the content and open it anyway, which is exactly why people think the rename worked - until something that actually validates the format rejects it. Python agrees about what it really is:

>>> Image.open("renamed.jpg").format
'WEBP'

The no-install route: WIC via PowerShell

Add-Type -AssemblyName PresentationCore

$src   = "C:\Pictures\image.webp"
$frame = [System.Windows.Media.Imaging.BitmapDecoder]::Create([Uri]$src, 'None', 'OnLoad').Frames[0]
$enc   = New-Object System.Windows.Media.Imaging.JpegBitmapEncoder
$enc.QualityLevel = 90
$enc.Frames.Add($frame)
$out = [System.IO.File]::Create([IO.Path]::ChangeExtension($src, '.jpg'))
$enc.Save($out); $out.Close()

BitmapDecoder.Create picks the codec by content, and on a machine with the WebP extension you can confirm which one it chose:

$dec = [System.Windows.Media.Imaging.BitmapDecoder]::Create([Uri]$src, 'None', 'OnLoad')
$dec.CodecInfo.FriendlyName   # -> Microsoft Webp Decoder

A whole folder is the same thing in a loop:

Add-Type -AssemblyName PresentationCore

Get-ChildItem "C:\Pictures\*.webp" | ForEach-Object {
    $f = [System.Windows.Media.Imaging.BitmapDecoder]::Create([Uri]$_.FullName, 'None', 'OnLoad').Frames[0]
    $e = New-Object System.Windows.Media.Imaging.JpegBitmapEncoder
    $e.QualityLevel = 90
    $e.Frames.Add($f)
    $o = [System.IO.File]::Create([IO.Path]::ChangeExtension($_.FullName, '.jpg'))
    $e.Save($o); $o.Close()
}

Gotcha 1: the alpha channel is gone

This is the part worth knowing before you run it over a folder of logos. The frame that comes back from the Microsoft WebP decoder is Bgr32 - no alpha. Transparent pixels arrive black, and because the data is already flattened, switching to PngBitmapEncoder doesn't save you:

$f.Format              # -> Bgr32
# transparent WebP -> PNG, then inspect the corner pixel:
#   (0, 0, 0, 255)     # opaque black, not transparent

Pillow reads the same file as RGBA, so if transparency matters, do it in Python and decide what goes behind it:

from PIL import Image
from pathlib import Path

for src in Path(".").glob("*.webp"):
    im = Image.open(src)
    if im.mode in ("RGBA", "LA", "P"):       # composite onto white instead of black
        im = im.convert("RGBA")
        bg = Image.new("RGB", im.size, (255, 255, 255))
        bg.paste(im, mask=im.split()[3])
        im = bg
    im.convert("RGB").save(src.with_suffix(".jpg"), quality=90)

Gotcha 2: animated WebP silently loses everything after frame 1

The decoder does expose the frames - $dec.Frames.Count returned 4 for my test file, and Pillow reported n_frames = 4 for the same one. But Frames[0] is what the snippet above encodes, and JPEG has nowhere to put the rest. If the motion matters, GIF is two lines:

Image.open("anim.webp").save("anim.gif", save_all=True, loop=0)

And it gets bigger

WebP -> JPG is a re-encode of already-lossy data, so you pay twice: a little more generation loss, and usually a larger file. My 2.6 KB test WebP became 7.4 KB as a quality-90 JPEG. That tracks with Google's own numbers - lossy WebP is 25-34% smaller than JPEG at equivalent SSIM, lossless is 26% smaller than PNG - so converting "to save space" is backwards. Keep the original, and if size is the goal, resize instead of re-encoding.

Quick reference

Need	Use
One or two files, no install	Any browser-based converter that runs client-side
A folder, nothing installed	PowerShell + WIC (above)
Transparency preserved or flattened your way	Pillow
Animation kept	Pillow -> GIF

Everything above was run on Windows 11 with Microsoft.WebpImageExtension 1.2.31: the codec name, the Bgr32 frame format, the black corner pixel, the frame counts and the file sizes are measured, not assumed.

Longer version with the non-developer paths (Paint, Photos, a drag-and-drop converter that doesn't upload): https://www.coding-now.com/en/guides/webp-to-jpg?utm_source=devto

Has the alpha-drop bitten anyone else, or is there a WIC flag I missed?

Transparent PNGs: the 3 background-removal algorithms, why JPG can't do it, and the color-key gotcha

코딩나우(하늘아래) — Tue, 22 Sep 2026 01:39:12 +0000

Every "make this background transparent" tool is doing one of three things under the hood, and picking the wrong one for your picture is why a logo comes back with a hole in it, or the background is only half gone.

Transparency lives in the alpha channel

A pixel needs a fourth value beyond R, G, B: alpha, how see-through it is. Only formats that define an alpha channel can store it - PNG and WebP per-pixel, GIF as one fully-transparent color, never JPEG.

This isn't an implementation detail, it's in the spec. The HTML Living Standard says it outright for canvas export:

For image types that do not support an alpha component, the serialized image must be the bitmap image composited onto an opaque black background using the source-over compositing operator.

So canvas.toBlob(cb, 'image/jpeg') on a transparent canvas doesn't warn you, it silently paints black behind everything and hands you that. Pillow is less quiet about it - trying to save an RGBA image as JPEG raises OSError: cannot write mode RGBA as JPEG outright.

The three removal methods

AI subject detection - segments the main subject (person, product, animal) from everything else. Handles busy backgrounds, one click, but check fine edges (hair, glass) before you trust it. This is what Windows 11 Paint's Remove Background button and the Photos app do (Paint since the update Microsoft announced in Sept 2023, version 11.2306.30).

Connected area (flood fill / magic wand) - starts at a point you click and grows outward through similar, touching colors. GIMP's Fuzzy Select and macOS Preview's Instant Alpha both work this way. If the background is split into several disconnected regions by the subject, you click each region.

Color key - removes every pixel close to one chosen color, anywhere in the image. GIMP's Color to Alpha and PowerPoint's Set Transparent Color use this. Fast on a flat background, but if that color also shows up inside the subject, it goes transparent too.

I actually ran both non-AI methods on the same test image with Pillow - a blue circle logo on white, with a white square cut out in the middle (standing in for white text or a hole in a badge):

from PIL import Image, ImageDraw

# color key: kill every near-white pixel in the whole image
def color_key(im, key=(255, 255, 255), tol=30):
    im = im.convert("RGBA")
    px = im.load()
    for y in range(im.height):
        for x in range(im.width):
            r, g, b, a = px[x, y]
            if abs(r-key[0])<=tol and abs(g-key[1])<=tol and abs(b-key[2])<=tol:
                px[x, y] = (r, g, b, 0)
    return im

# connected area: flood fill from a known-background pixel
img = Image.open("logo.png").convert("RGBA")
ImageDraw.floodfill(img, (0, 0), (255, 255, 255, 0), thresh=30)

Color key made the inner white square transparent along with the background - a hole in the logo. Flood-fill from the corner only removed the background that's actually connected to it, leaving the inner square intact. Same tolerance, same image, opposite result, because they're answering different questions ("is this pixel near white?" vs "is this pixel reachable from here through near-white pixels?").

Rule of thumb: if the background color repeats inside the subject (white lettering on a white-background logo, a stamp with a white rim), color key gives you a hole - use flood fill or AI instead.

Doing it in bulk: rembg

For more than a couple of images, rembg (MIT license, Python 3.11-3.13) wraps several AI segmentation models behind one CLI:

pip install "rembg[cpu,cli]"

rembg i photo.jpg photo-cutout.png        # one file
rembg p input_folder output_folder        # a whole folder

It downloads the model on first use (cached under ~/.rembg/models/) and runs locally after that - nothing gets uploaded, which matters if the images aren't meant to leave your machine. The many online "remove.bg"-style tools are AI too, but the file goes to their server; fine for anything you'd publish anyway, not for scanned IDs or internal docs.

In the browser, without a server round-trip

If you're building this into a web page rather than a script, the color-key approach is a <canvas> pixel loop plus a distance check - no upload, no dependency:

function knockoutBackground(imageData, [kr, kg, kb], tolerance) {
  const d = imageData.data;
  for (let i = 0; i < d.length; i += 4) {
    const dist = Math.hypot(d[i]-kr, d[i+1]-kg, d[i+2]-kb);
    if (dist <= tolerance) d[i+3] = 0;
  }
  return imageData;
}

I use this approach (plus a small feather at the tolerance edge, to soften jagged outlines) in a small image converter tool - drop an image, eyedropper the background, adjust tolerance, export as PNG or WebP. Same color-key limitation applies: same-color pixels inside the subject go transparent too.

Full write-up with the side-by-side comparison image, Paint/Photos/PowerPoint/Preview steps, and a troubleshooting list: https://www.coding-now.com/en/guides/transparent-background-png?utm_source=devto

What's your go-to for batch background removal - rembg, something cloud-based, or hand-rolled?

No HyperTerminal on Windows 10/11? Free serial terminals and the 4 settings that matter

코딩나우(하늘아래) — Mon, 21 Sep 2026 06:59:17 +0000

Old equipment manuals still say "connect with HyperTerminal". On Windows 10 or 11 you won't find it: according to Hilgraeve, who wrote it and licensed it to Microsoft, it stopped shipping with Windows Vista and 7. Hilgraeve still sells HyperTerminal Private Edition ($69.99 as of September 2026, free trial), but free tools cover everything it did.

And no, Windows Terminal doesn't do serial. The GitHub request for it (microsoft/terminal #1280) has been open since 2019 and sits in the Icebox milestone.

1. Find the COM port

Device Manager -> Ports (COM & LPT). Unplug and replug the device; the entry that disappears and returns is yours. Or ask PowerShell:

[System.IO.Ports.SerialPort]::GetPortNames()
Get-PnpDevice -Class Ports -PresentOnly | Select-Object Status, FriendlyName

No port at all? Install the adapter chip's driver (CH340, CP210x, FTDI) and rule out a charge-only USB cable.

A big number like COM34 is harmless. On the PC I wrote this on, nine unplugged port devices still carried COM3 to COM20, while the board plugged in right now was on COM34. One catch: through the Win32 API, ports above 9 must be opened as \\.\COM10 (per the CreateFile docs), and some old programs never learned that.

2. The four settings

A serial line has no negotiation. Both ends assume the same rules, and if one differs the port still opens but the output is wrong.

Setting	Usual value	Symptom when wrong
Speed (baud)	9600 or 115200	A stream of unreadable characters
Data format	8N1	Only some characters come out wrong
Flow control	None	Sending stalls, or certain bytes vanish
Line ending	CR, LF or CR+LF	Commands get no reply

8N1 is 8 data bits, no parity, 1 stop bit, and it's what Arduino's Serial.begin() uses unless told otherwise. 7E1 (7 data bits, even parity) is the same length on the wire, which is why the speed can be right and some characters still turn into others. You'll meet it in things like Modbus ASCII.

PuTTY gotcha: its default serial flow control is XON/XOFF (per the defaults in its source). XON/XOFF sends 0x11 and 0x13 inside the data stream, so binary data containing those bytes gets eaten as flow control. Set Connection > Serial > Flow control to None unless your device really uses it.

3. The free programs

PuTTY - Session > Connection type: Serial, Serial line COM3, Speed. Data bits, parity and flow control live under Connection > Serial. Blank window? Press Enter a few times; some devices wait for the PC to speak first. Shortcut-friendly:

putty.exe -serial COM3 -sercfg 115200,8,n,1,N

The same options work with plink, so a Windows Terminal profile running plink.exe -serial COM3 -sercfg 115200,8,n,1,N turns a tab into a serial console (syntax per the PuTTY manual).

Tera Term - the closest thing to HyperTerminal, including XMODEM/YMODEM/ZMODEM/Kermit file transfer under File > Transfer. File > New connection > Serial, then Setup > Serial port for the line settings. You can't switch ports from that dialog while connected; disconnect first. 5.7.0 (Sept 2026) ships as an installer and as a plain ZIP.

RealTerm - open source, built for binary streams: hex and 8/16/32-bit views, timestamped capture. Port tab for speed and port.

CNTerminal (my tool, open source) - one 8 MB exe, no install: hex send/receive, an ASCII/hex converter, a preview of the exact bytes before sending, and a DTR toggle so an ESP32 doesn't reset on connect. Honest limit: it's fixed at 8N1 with no flow control, so use Tera Term for 7E1 gear or XMODEM.

4. Nothing installable? PowerShell

Windows PowerShell 5.1 ships with Windows and can use .NET's SerialPort directly:

$port = New-Object System.IO.Ports.SerialPort 'COM3', 115200, 'None', 8, 'One'
$port.ReadTimeout = 2000
$port.Open()
$port.WriteLine('AT')      # default line ending is LF
try { $port.ReadLine() } catch { 'no reply' }
$port.Close()

Defaults I checked: 9600, 8N1, no handshake, DTR and RTS both off. The open errors tell you what's wrong:

Access to the port 'COM3' is denied. - another program (Arduino serial monitor, another terminal, an upload tool) already has it open.
The port 'COM99' does not exist. - wrong number, or the device is unplugged.

mode COM3 in a command prompt prints the port's current speed, parity, data bits and DTR/RTS state.

Checklist when nothing shows up

Port not listed: driver, cable, another USB socket.
Port won't open: close whatever else holds it.
Garbled text: fix the speed; if only some characters are off, check 8N1 vs 7E1.
No reply: try CR, LF and CR+LF. Can't see what you type? The device doesn't echo; turn on local echo.
Board reboots on connect: that's the DTR/RTS auto-reset circuit on ESP32 and Arduino boards.

The full guide, with diagrams and a side-by-side comparison table:

Guide: https://www.coding-now.com/en/guides/hyperterminal-alternative?utm_source=devto
CNTerminal (free, no install): https://www.coding-now.com/en/cnterminal?utm_source=devto

What are you still using HyperTerminal-era manuals for?

Text to speech on Windows: the built-in voices, edge-tts, and why subtitle dubbing never fits

코딩나우(하늘아래) — Mon, 21 Sep 2026 01:02:18 +0000

Narration for a video, a spoken prompt in an app, a subtitle file turned into audio: all of it starts with getting text read out and saved to a file. Windows can do it with what's already installed, and the neural voices are a pip install away. Here's what each route costs you.

The voices already in Windows

Narrator and Edge's Read Aloud use the built-in speech engine, but neither will save what it reads. System.Speech will:

Add-Type -AssemblyName System.Speech
$s = New-Object System.Speech.Synthesis.SpeechSynthesizer

# What's available
$s.GetInstalledVoices() | ForEach-Object { $_.VoiceInfo.Name + " (" + $_.VoiceInfo.Culture + ")" }

$s.SelectVoice("Microsoft Zira Desktop")
$s.Rate = 0                      # -10 .. 10
$s.SetOutputToWaveFile("C:\temp\narration.wav")
$s.Speak((Get-Content "C:\temp\script.txt" -Raw -Encoding UTF8))
$s.Dispose()

No install, no network, and it writes a WAV. The delivery is unmistakably synthetic, so it suits prompts and beeps more than narration.

The gotcha: added voices that never show up

Add a voice under Settings > Time & language > Speech and it often doesn't appear in GetInstalledVoices(). The two generations of voices live in different registry hives:

# SAPI 5 - what System.Speech reads
Get-ChildItem 'HKLM:\SOFTWARE\Microsoft\Speech\Voices\Tokens'

# OneCore - what Settings installs, and Narrator uses
Get-ChildItem 'HKLM:\SOFTWARE\Microsoft\Speech_OneCore\Voices\Tokens'

On the Windows 11 (25H2) machine I checked, the SAPI hive had two voices and the OneCore hive had a third one that System.Speech could never select. If a voice you installed isn't in the list, this is why.

Neural voices from the command line

The voices Edge reads pages with are neural, and edge-tts drives them directly:

pip install edge-tts

# text -> MP3, with a matching .srt
edge-tts --text "Hello, world!" --write-media hello.mp3 --write-subtitles hello.srt

edge-tts --list-voices

# a script file, in a chosen voice
edge-tts --voice en-US-AriaNeural --file script.txt --write-media narration.mp3

edge-tts --rate=-50% --text "Hello, world!" --write-media slower.mp3
edge-tts --volume=-50% --text "Hello, world!" --write-media quieter.mp3
edge-tts --pitch=-50Hz --text "Hello, world!" --write-media lower.mp3

Options are from the project's README and CLI help. No API key, no account, and it writes MP3 rather than WAV, which matters once a batch of scripts piles up.

Dubbing subtitles: the lengths never match

A subtitle file states exactly how long each line is on screen. Read that line aloud and it is nearly always longer, because people skim subtitles while a synthesizer pronounces every syllable. Translate first and the gap widens.

cue  1  00:00:00,000 --> 00:00:03,500   (3.5s)   speech 3.2s   fits
cue  2  00:00:03,500 --> 00:00:07,000   (3.5s)   speech 4.6s   overruns into cue 3
cue  3  00:00:07,000 --> 00:00:12,000   (5.0s)   speech 4.4s   fits

What actually works:

Raise the rate. 10-20% faster still sounds natural.
Shorten the line. The narration doesn't have to match the subtitle word for word.
Merge two short cues into one sentence, which buys room either side.
If it has to be frame-accurate, cut per cue in an editor instead of fighting the timings.

Making something new rather than dubbing? Generate the narration first and cut the visuals to its length. Then nothing has to be squeezed.

The part people skip: licensing

ElevenLabs free tier: 10k credits a month, and no commercial licence on the free plan (paid starts at $6/month).
Naver Clova Dubbing free tier: monthly download and character limits, attribution required, ads and promotion need a paid plan.
The Edge neural voices have no quota through edge-tts, but they are Microsoft's service, so read the terms before shipping commercial work.

Figures are from September 2026 and these terms change often. "Free to generate, but not for monetised content" is a common combination, and it's the sort of thing that surfaces after the video is published.

The full version, with diagrams and a GUI option for people who don't want a terminal:

Guide: https://www.coding-now.com/en/guides/text-to-speech-mp3?utm_source=devto

Which route do you use for narration?

Windows Task Scheduler: why your scheduled task doesn't run (and what 0x41303 means)

코딩나우(하늘아래) — Fri, 18 Sep 2026 01:05:40 +0000

Creating a scheduled task in Windows takes five minutes. Then the time comes and nothing happens, or the program starts but you never see its window. Almost always it's one of a few defaults. The defaults below come from New-ScheduledTaskSettingsSet, and the result codes from Microsoft's Task Scheduler constants.

The four gates

A task has to get through four gates before anything visible happens:

1. Trigger           -> 0x41303: the task has not yet run
2. Conditions        -> on battery: doesn't start (default)
3. Security options  -> "whether user is logged on or not": no window
4. Action            -> 0x80070002: file not found, 0x1: the program's exit code

The Status and Last Run Result columns and the History tab tell you which gate stopped it. If History is empty, click Enable All Tasks History in the Actions pane. The same events are in Event Viewer under Applications and Services Logs > Microsoft > Windows > TaskScheduler > Operational.

No window: the security option

Run whether user is logged on or not runs the task in session 0, not on your desktop. A GUI program still starts but never shows up, and the task sits at 0x41301 (currently running). The default for an already running task is Do not start a new instance, so the next scheduled run is skipped too.

Programs you need to see: Run only when user is logged on, the default for Create Basic Task.
Scripts that need no window: whether logged on or not, which also stops the console window flashing. You have to save the password. Do not store password uses an S4U logon, which per Microsoft's docs has no access to the network or encrypted files, so skip it for backups to a NAS.

Only fails on a laptop: the power conditions

Two defaults on the Conditions tab:

Start the task only if the computer is on AC power: on
Stop if the computer switches to battery power: on

Clear both for tasks that should run on battery.

The other defaults

New-ScheduledTaskSettingsSet with no arguments shows them:

DisallowStartIfOnBatteries : True
StopIfGoingOnBatteries     : True
StartWhenAvailable         : False   <- runs missed while the PC was off are skipped
WakeToRun                  : False
ExecutionTimeLimit         : PT72H   <- stopped after 3 days
MultipleInstances          : IgnoreNew

The 3-day limit bites anything meant to stay open, like trading apps or servers. And an empty Start in (optional) makes the task run from C:\Windows\System32, so a program that loads its config from a relative path fails only when scheduled. For a batch file, cd /d "%~dp0" on the first line fixes it.

Reading Last Run Result

Code	Meaning
`0x0`	Success (exit code 0)
`0x41301`	The task is currently running
`0x41303`	The task has not yet run
`0x80070002`	The system cannot find the file specified
`0x800710E0`	The operator or administrator has refused the request
`0x1`, `0x2` ...	Usually the program's own exit code

0x41303 isn't a fault. Plenty of built-in tasks only run in specific situations: on the PC I checked, 76 of about 200 tasks showed it. For a batch file that ends with 0x1, append >> log.txt 2>&1 to its commands to see which one failed.

Creating it from the command line

schtasks has no Start in option, so if you need one, use PowerShell and fix the defaults while you're at it:

$action   = New-ScheduledTaskAction -Execute "C:\Tools\report.exe" -WorkingDirectory "C:\Tools"
$trigger  = New-ScheduledTaskTrigger -Daily -At 9am
$settings = New-ScheduledTaskSettingsSet -AllowStartIfOnBatteries -DontStopIfGoingOnBatteries -StartWhenAvailable -ExecutionTimeLimit ([TimeSpan]::Zero)
Register-ScheduledTask -TaskName "Morning report" -Action $action -Trigger $trigger -Settings $settings

For quick one-liners schtasks is fine. Paths with spaces need an inner pair of single quotes:

schtasks /create /tn "Report" /tr "'C:\Program Files\Report\report.exe' --quiet" /sc daily /st 07:00
schtasks /run /tn "Report"
schtasks /query /tn "Report" /v /fo list

The full guide, with diagrams and the Create Basic Task walkthrough:

Guide: https://www.coding-now.com/en/guides/windows-task-scheduler?utm_source=devto

Which default has bitten you?

ESP32 upload errors decoded: 'Failed to connect', 'Wrong boot mode detected' and friends

코딩나우(하늘아래) — Thu, 17 Sep 2026 11:21:59 +0000

ESP32 uploads fail in a handful of ways, and the error text already tells you where it stopped. Arduino IDE, PlatformIO and ESP-IDF all upload through esptool, so the messages are the same everywhere. The wording below is taken from the esptool source (v4.8.1 and current master).

The four stages

1. open the port        -> Could not open COM3, the port is busy or doesn't exist.
2. reset into download  -> Wrong boot mode detected (0x13)! The chip needs to be in download mode.
3. sync with the chip   -> No serial data received.
                           Download mode successfully detected, but getting no sync reply: The serial TX path seems to be down.
4. write flash          -> Invalid head of packet (0x..): Possible serial noise or corruption.
                           Serial data stream stopped: Possible serial noise or corruption.

Everything starts with A fatal error occurred:, and connection-stage errors add Failed to connect to ESP32: (the chip name changes with the board).

Could not open COM3, the port is busy or doesn't exist

The line under it is the real cause:

(could not open port 'COM3': PermissionError(13, 'Access is denied.', None, 5))

PermissionError(13, ...) means another program has the port open, like a terminal or a serial monitor in another IDE window. FileNotFoundError(2, ...) means there is no port with that name. Close whatever holds the port, unplug and replug the board with Device Manager open to spot the real port, install the USB chip driver (Silicon Labs for CP210x, WCH for CH340), and make sure the cable has data lines.

A detail from the source: esptool adds its Hint: line by matching the English text Access is denied. On a non-English Windows that text is localized, so the busy-port hint may not show up at all. On Linux, Permission denied means your user needs to be in dialout (or uucp).

No serial data received

The port opened, but after the reset not a single byte came back.

Manual download mode: hold BOOT while Connecting... is printed. If that isn't enough, keep holding BOOT and tap EN. Let go once Writing at 0x... appears.
Plug straight into the PC with a short data cable, no hub.
Power: the esptool docs say the 3.3 V supply has to handle 200-300 mA peaks. Disconnect motors, LED strips and other hungry parts.
Bare module on a USB-serial adapter: adapter TX to ESP32 RX, adapter RX to ESP32 TX, common ground.
Lower the upload speed (see below).

Wrong boot mode detected (0x13)

Half good news: esptool read the boot log, so the serial link works. The chip just booted the app in flash instead of download mode. esptool decides this by looking for waiting for download in the boot log it reads right after the reset:

boot:0x13 (SPI_FAST_FLASH_BOOT)                       <- GPIO0 was HIGH at reset: normal boot
boot:0x3 (DOWNLOAD_BOOT(UART0/UART1/SDIO_REI_REO_V2))
waiting for download                                  <- GPIO0 was LOW: download mode

Hold BOOT during Connecting....
Remove anything wired to GPIO0 or GPIO2. GPIO0 held HIGH blocks download mode, and GPIO2 must be floating or LOW to enter it.
GPIO12 pulled HIGH selects 1.8 V flash voltage, which breaks boards with 3.3 V flash.
If every single upload needs BOOT, suspect the board's auto-reset timing or a USB hub before your code.

No sync reply: the serial TX path seems to be down

Download mode was detected, so the chip's output reaches the PC, but it never answers esptool. Only the PC-to-ESP32 direction is broken. With an adapter, check adapter TX to ESP32 RX (GPIO3, U0RXD). On a dev board this is rare, so try another board with the same cable and PC.

Invalid head of packet / Serial data stream stopped

The upload starts and dies partway. The esptool docs point at poor cables, pins shorting on a breadboard, and brownouts. Slow it down:

Tool	Setting
Arduino IDE	Tools > Upload Speed > `115200`
PlatformIO	`upload_speed = 115200`
ESP-IDF	`idf.py -p COM3 -b 115200 flash`
esptool	`-b 115200` (the docs go as low as `-b 9600` to diagnose)

Also keep stray wires off the flash pins (GPIO6-11 on the classic ESP32) and give high-current parts their own supply during uploads.

After a successful upload

If nothing runs, the chip is probably still in download mode, so press EN. On an ESP32-S3 or C3 flashed over native USB, that reset doesn't re-sample the strapping pins, and esptool's --after watchdog-reset handles it.

The full version with diagrams, plus the companion post on why the board resets whenever a serial monitor opens:

Guide: https://www.coding-now.com/en/guides/esp32-upload-failed-to-connect?utm_source=devto
Serial monitor resets: https://www.coding-now.com/en/guides/esp32-serial-monitor-reset?utm_source=devto

Which of these do you run into most?

Why your ESP32 resets every time you open the serial monitor (and how to stop it)

코딩나우(하늘아래) — Thu, 17 Sep 2026 08:08:15 +0000

You flash the firmware, open a serial monitor to see what it is doing, and the board reboots, wiping out exactly the state you wanted to look at.

Nothing is broken. The auto-reset circuit that makes uploading convenient reacts to the monitor in exactly the same way. Once you see how it works, the fix is a line or two.

Why opening the port resets the board

ESP32 dev boards (DevKitC and friends) carry a USB-to-serial chip such as a CP2102 or CH340. Its DTR and RTS pins drive EN (reset) and IO0 (boot mode) through two transistors. Upload tools use those lines to put the chip into download mode and reset it automatically, which is why you rarely press the buttons.

But upload tools are not the only software touching those lines. Most terminal programs and drivers raise or drop DTR/RTS when they open a port. The circuit cannot tell an upload from a monitor, so it resets the chip either way.

For the auto-bootloader circuit most boards use, it only reacts when the two lines differ:

DTR	RTS	EN	IO0	Result
1	1	1	1	Normal run
0	0	1	1	Normal run
1	0	0	1	Held in reset
0	1	1	0	Boot-mode select (IO0 low)

If the two lines don't change at exactly the same instant when the port opens, that brief mismatch is enough to reset the chip. So the fix is to not touch either line at all. (Board vendors vary the circuit slightly, so details can differ.)

Fixes by tool

PlatformIO

Two lines in platformio.ini stop the monitor from driving the lines. Uploads are unaffected, because the uploader controls them separately.

[env:esp32dev]
platform = espressif32
board = esp32dev
framework = arduino
monitor_speed = 115200
monitor_dtr = 0
monitor_rts = 0

Not on native-USB boards. On an ESP32-S3 or C3 talking over the built-in USB-Serial/JTAG (no bridge chip), driving both lines low is itself a reset trigger, so these two lines make it reset every time. Leave them out so the monitor never touches DTR/RTS.

ESP-IDF

idf.py monitor deliberately resets the board on start so you see the boot log. To attach to a board that is already running, recent versions accept --no-reset:

idf.py -p COM5 monitor --no-reset

Python (pyserial)

Turning the lines off after opening is too late. Create the port object first, set the line states, then call open():

import serial

ser = serial.Serial()        # not opened yet
ser.port = "COM5"
ser.baudrate = 115200
ser.dtr = False              # decide before opening
ser.rts = False
ser.open()

while True:
    line = ser.readline()
    if line:
        print(line.decode(errors="replace"), end="")

Arduino IDE

The Arduino IDE serial monitor generally has no option to leave these lines alone. If you need to watch without a reset, PlatformIO or a terminal with a DTR control is the quicker route.

Stuck on `waiting for download`

Sometimes opening the monitor shows only this, and your program never starts:

rst:0x1 (POWERON_RESET),boot:0x3 (DOWNLOAD_BOOT(UART0/UART1/SDIO_REI_REO_V2))
waiting for download

DOWNLOAD_BOOT means IO0 was low at the moment of reset, so the chip skipped your firmware and is waiting for a new one. That is the last row of the table (DTR 0, RTS 1).

Close the monitor and press EN (RST) once. With the lines released, it boots normally.
Reopen the monitor with RTS off, using the settings above.
If you wired buttons or sensors to GPIO0, check that nothing holds it low during boot.

Sometimes you want the reset

If you are after the messages printed right at boot, like crash reasons or init logs, the auto-reset is a feature. Keep the defaults, or open the monitor with the lines off and press EN yourself.

Cutting the board's auto-reset traces, or using a USB-serial adapter wired for TX, RX and GND only, removes monitor resets entirely. The price: every upload needs BOOT held while you tap EN.

Quick answers

Arduino Uno does this too? Similar idea. DTR reaches the reset pin through a capacitor, so opening the port resets it once. Around 10 µF between RESET and GND prevents it, but remove it before uploading.
Won't DTR/RTS off break uploads? No. monitor_dtr / monitor_rts only apply to the monitor.
Wrong boot mode detected on upload? The auto-reset failed to enter download mode. Suspect charge-only cables and flaky hubs, or hold BOOT until Connecting... appears.
ESP32-S3 / C3 native USB? Same symptom, reversed fix: don't set monitor_dtr / monitor_rts at all, because both lines low is one of the combinations that resets the chip there. ESP_RST_USB in the boot log (ESP-IDF 5.1.4+) tells you the monitor did it. The upload side is unchanged: its reset doesn't re-sample the strapping pins, so if a board stays in download mode after flashing, press EN once or use esptool's --after watchdog-reset.

Longer version with a diagram, plus CNTerminal, a free portable serial terminal from the same site whose DTR toggle opens the port without resetting the board:

Guide: https://www.coding-now.com/en/guides/esp32-serial-monitor-reset?utm_source=devto
CNTerminal (free, no install): https://www.coding-now.com/en/cnterminal?utm_source=devto

Which board or tool has caught you out with this?

JSON.parse errors decoded: what 'Unexpected token <' and friends actually mean

코딩나우(하늘아래) — Thu, 17 Sep 2026 07:57:13 +0000

JSON errors arrive as one terse line, but the causes behind them are a short list: the server sent HTML instead of JSON, there was nothing to parse, or the JSON was written by hand like a JavaScript object.

The Chrome, Node.js and Python messages below come from actually running each input through Chrome 152, Node.js 24 and Python 3.11, so you can match yours word for word.

Read the position first

For {"name": "kim", "age": 20,} (note the trailing comma):

Environment	Message
Chrome, Edge, Node.js	`Expected double-quoted property name in JSON at position 26 (line 1 column 27)`
Python `json`	`Expecting property name enclosed in double quotes: line 1 column 27 (char 26)`
Older Chrome / Node.js	`Unexpected token } in JSON at position 26`

position (and Python's char) counts from 0. line and column count from 1, like your editor.

{"name": "kim", "age": 20,}
                         ^ position 25: the comma you actually need to delete
                          ^ position 26: where the parser gave up

The reported spot is where the parser could no longer continue, not where you made the mistake. Start there and read backwards.

`Unexpected token '<'` — you got HTML, not JSON

Chrome/Edge : SyntaxError: Failed to execute 'json' on 'Response': Unexpected token '<', "<!DOCTYPE "... is not valid JSON
Firefox     : SyntaxError: JSON.parse: unexpected character at line 1 column 1 of the JSON data
Safari      : SyntaxError: JSON Parse error: Unrecognized token '<'

The < is the start of <!DOCTYPE html>. Staring at the code that builds your JSON will not help — the server sent a document. Usual suspects: a typo in the API path (404 page), a server crash (500 page), an expired session redirecting to a login page, or a dev server without a proxy returning index.html for /api/....

Open DevTools → Network → the request → Response. If you see HTML, that is your answer. Then stop it from hiding the real cause:

const res = await fetch("/api/users");
if (!res.ok) {
  throw new Error(`HTTP ${res.status}`);
}
const type = res.headers.get("content-type") ?? "";
if (!type.includes("application/json")) {
  const body = await res.text();
  throw new Error(`Expected JSON, got: ${body.slice(0, 80)}`);
}
const data = await res.json();

`Unexpected end of JSON input` — nothing to parse

You parsed an empty string: a 204 No Content response, an empty error body, or a zero-byte file. Python reports this and the HTML case identically as Expecting value: line 1 column 1 (char 0), so print what you received.

Truncated JSON looks different: {"name": "kim", "tags": ["a", "b" gives Expected ',' or ']' after array element in JSON at position 33. If the position is the very end of the input, suspect a cut-off response or a log copied without its tail.

JavaScript syntax is not JSON

Mistake	Example	Chrome / Node.js	Python
Trailing comma (object)	`{"a": 1,}`	`Expected double-quoted property name`	`Expecting property name enclosed in double quotes`
Trailing comma (array)	`[1, 2, 3,]`	`Unexpected token ']'`	`Expecting value`
Single quotes	`{'name': 'kim'}`	`Expected property name or '}'`	`Expecting property name enclosed in double quotes`
Unquoted key	`{name: "kim"}`	`Expected property name or '}'`	`Expecting property name enclosed in double quotes`
Comment	`{"a": 1 // note}`	`Expected ',' or '}' after property value`	`Expecting ',' delimiter`

Notice that the message rarely names the mistake. A comment does not say "comments are not allowed". Trust the position more than the wording. (And tsconfig.json accepting comments is why this habit sneaks into package.json — that one is JSONC, this one is not.)

Values JSON doesn't have

NaN, Infinity, undefined, Python's True/None, leading zeros (007) and hex (0x1F) all fail. Unexpected token 'N' covers both NaN and None, so read the quoted fragment after it.

The sneaky one: Python writes NaN by default and reads it back happily.

import json

json.dumps({"score": float("nan")})
# '{"score": NaN}'  <- not standard JSON; JavaScript will throw

json.dumps({"score": float("nan")}, allow_nan=False)
# ValueError: Out of range float values are not JSON compliant

Also: str(data) in Python gives {'ok': True, 'v': None} — not JSON. Use json.dumps().

Errors inside strings

Bad control character in string literal in JSON at position 14   <- a real newline or tab inside quotes; write \n
Bad escaped character in JSON at position 13                     <- "C:\Users\kim": \U is not an escape
Unexpected token '', "{"a": 1}" is not valid JSON                <- looks empty? that's a BOM

For the Windows path, use C:\\Users\\kim or C:/Users/kim. Python's message for the same input points one character earlier (char 12, the backslash) than V8 (position 13, the U).

The BOM case is invisible in most editors. On Windows, PowerShell 5.1 is a common source: Set-Content -Encoding UTF8 adds a BOM, and > or Out-File write UTF-16. Fixes: open(path, encoding="utf-8-sig") in Python, text.replace(/^\uFEFF/, "") in Node.js, or re-save as plain UTF-8.

`"undefined" is not valid JSON` and `"[object Object]"`

JSON.parse stringifies whatever you pass it.

"undefined" is not valid JSON — often localStorage.setItem("user", undefined), which stores the literal string "undefined".
"[object Object]" is not valid JSON — you parsed something already parsed, like axios's response.data.
Unexpected non-whitespace character after JSON — two JSON values back to back, e.g. a JSON Lines file parsed in one go. Split on newlines first.

Checklist

< in the message → check the response, not the JSON.
end of JSON input → empty or truncated input.
A position → look just before it.
Big file, no position → python -m json.tool file.json prints line 4 column 1-style locations.
Building JSON by string concatenation → switch to JSON.stringify() / json.dumps().

The full version with diagrams, plus a browser-only formatter that highlights the failing line (nothing is uploaded):

Guide: https://www.coding-now.com/en/guides/json-parse-errors?utm_source=devto
JSON formatter & validator: https://www.coding-now.com/en/json-formatter?utm_source=devto

Which of these has cost you the most debugging time?

Modbus RTU vs TCP: the same command in two different envelopes

코딩나우(하늘아래) — Wed, 16 Sep 2026 08:20:01 +0000

Equipment manuals say "supports Modbus" and leave you to work out whether that means RTU or TCP. The names make it sound like two protocols. It is one protocol with two envelopes.

The command you send — read these registers, write that coil — is byte-for-byte identical. Only the wrapper differs, and every practical consequence (wiring, update rate, device count, how you debug) falls out of that one difference.

The frames, side by side

RTU   [ slave addr 1B ][ function code + data  N B ][ CRC 2B ]
                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
TCP   [ txn id 2B ][ proto 2B ][ length 2B ][ unit id 1B ][ function code + data  N B ]
      \________________ MBAP header, 7 bytes ____________/

The part under the carets is the PDU, and it is the same in both. RTU frames are delimited by 3.5 character times of silence and carry a CRC. TCP frames have no CRC at all — TCP already guarantees integrity, which trips people up when they go hunting for one in a packet capture.

Because the PDU is shared, so are the function codes:

Code	Does	Target
`01`	Read coils	Output bits
`02`	Read discrete inputs	Input bits (read-only)
`03`	Read holding registers	16-bit values — the common one
`04`	Read input registers	16-bit values (read-only)
`05` / `06`	Write single coil / register	One value
`15` / `16`	Write multiple	A contiguous block

Wiring is where the real difference lands

RTU runs over two RS-485 wires, daisy-chained. Cheap, and it reaches past a kilometre at 9600 bps. Everyone shares the line, so the master polls one device at a time.

Fit 120 ohm terminators at both ends. Missing ones give intermittent errors that only show up once the cable gets long.
Vendors label A/B (D+/D-) inconsistently. Swapping the pair is the fastest test.
Run a common signal ground. Ground potential differences make the link flaky.
Addresses are 1-247, and two devices sharing one will collide on every reply.

TCP gives each device an IP on a switch. No new cabling if the network already exists, and several clients can talk at once — in exchange for the 100 m per-segment limit and IPs to manage.

How much faster is TCP, really?

Not raw bit rate — round-trip time. RTU at 9600 bps, 8N1, is 10 bits per byte, so roughly 1 ms per byte:

request 8 B + response 9 B = 17 B      ~ 18 ms
+ inter-frame silence (3.5 chars) x2   ~  7 ms
+ device processing                    ~  5-20 ms
-----------------------------------------------
one round trip                         ~ 30-45 ms  ->  20-30 per second

Ten slaves on that bus means two or three updates per device per second. Fine for temperature or flow; useless when you need tens of milliseconds. The same exchange on Ethernet is 1-5 ms, and devices can be polled in parallel.

The addressing trap that eats afternoons

When the manual says 40001, the number that goes on the wire is 0.

Manual says	On the wire	Function code
`40001`	`0`	`03` holding register
`40100`	`99`	`03`
`30001`	`0`	`04` input register
`00001`	`0`	`01` coil

And when a 32-bit value spans two registers, which half comes first is device-specific. A reading that is wildly large or unexpectedly negative is almost always reversed word order, not bad arithmetic — swap the two registers and recombine.

In Python, only the client line changes

# pip install pymodbus
from pymodbus.client import ModbusSerialClient, ModbusTcpClient

# RTU - serial port
client = ModbusSerialClient(port="COM3", baudrate=9600,
                            parity="N", stopbits=1, bytesize=8)

# TCP - IP address (this line instead of the one above)
# client = ModbusTcpClient("192.168.0.50", port=502)

client.connect()
rr = client.read_holding_registers(address=0, count=2, slave=1)
print(rr.registers)
client.close()

That is pymodbus 3.x; version 2.x used unit=1 instead of slave=1.

When nothing answers

RTU

Match baud rate, parity and stop bits exactly. 9600 8N1 against 9600 8E1 gives you silence.
Swap A/B.
Check for duplicate slave addresses, and whether the manual is 0- or 1-based.
Check the terminators and the common ground.
Connect a single slave directly. One works but several fail? Wiring or termination.

TCP

ping first, then check port 502 — firewalls block it regularly.
Check the Unit ID. Behind a gateway it has to match the serial slave address.
Check the connection limit; cheap devices accept one or two sockets and refuse the rest.
Capture with Wireshark. An exception reply is the function code plus 0x80: 02 means a bad address, 03 a bad quantity.

Longer version with diagrams, plus a free robot-communication track that builds a Modbus server and client on a single PC:

Guide: https://www.coding-now.com/en/guides/modbus-rtu-vs-tcp?utm_source=devto
Robot communication lessons (free): https://www.coding-now.com/en/blog/robot-comm?utm_source=devto

What tripped you up the first time you wired up Modbus? For me it was terminators — everything worked on the bench and fell apart in the panel.

Decoding Keil µVision build errors: what each message actually means

코딩나우(하늘아래) — Wed, 16 Sep 2026 05:07:06 +0000

Keil µVision tells you a build failed with something like L6218E or #67, and that's about it. No hint about which file to open, no suggestion of what to try. The first few times, you end up pasting the code into a search box and hoping.

In practice the same handful of errors account for most lost afternoons, and each one has a small set of likely causes. Here they are, grouped by the stage that produced them.

First: which stage failed?

Before reading the message itself, look at its prefix. It tells you where to look, which cuts the search space in half.

Prefix	Stage	What it means
`#20`, `#67` ...	Compile	C syntax or types — inside that one `.c` file
`L6218E`, `L6050U` ...	Link	Files compiled fine, combining them failed
`A1586E` ...	Assemble	Assembly file, usually the startup code
`*** error 65`	Simulator	Not a build failure at all

One more habit worth forming: fix the first error, then rebuild. Thirty errors rarely means thirty mistakes — usually one early failure cascades.

Link errors

L6050U — "the code size of this image exceeds the maximum"

Error: L6050U: The code size of this image (35128 bytes) exceeds the maximum
allowed for this version of the linker.

Nothing is wrong with your code. The free MDK-Lite edition caps output at 32 KB, and you crossed it. In order of effort:

Raise optimisation to -O2 or higher (Options for Target > C/C++). Often enough on its own.
Drop printf. The full formatter pulls in kilobytes; send debug output over UART directly, or enable MicroLIB (Options for Target > Target).
Remove driver and library files the project doesn't actually use.
Beyond that you need a full licence — the limit is not configurable.

If this is a learning project on STM32, note that ST's own STM32CubeIDE is free with no size limit.

L6218E — Undefined symbol

Error: L6218E: Undefined symbol delay_ms (referred from main.o).

The linker found the call but not the body. Check in this order:

Is the .c file that defines the function actually in the project tree? Including the header and forgetting the .c is the most common cause by a wide margin.
Do spelling and case match between declaration and definition?
Calling C from C++? It needs extern "C".
Undefined symbol main means main is missing, or main.c is excluded from the build.

L6236E — No section matches selector

Error: L6236E: No section matches selector - no section to be FIRST/LAST.

The startup file (startup_xxx.s) is missing. Add the one for your device, or tick Device > Startup in Manage Run-Time Environment. Switching target devices and leaving the old startup file behind gives the same error.

Link errors are project-structure problems. Reading source code won't reveal them — start from the file list in the Project pane.

Compile errors

Message	Cause	Fix
`#5: cannot open source input file "stm32f4xx.h"`	Include path not registered	Add the folder under C/C++ > Include Paths
`#20: identifier "GPIOA" is undefined`	Device header missing, or device macro undefined	Add the macro (e.g. `STM32F407xx`) under C/C++ > Define
`#67: expected a "}"`	Missing brace or semicolon	Look at the line before the reported one
`#513: a value of type ... cannot be assigned`	Type mismatch	Cast explicitly between pointers and integers

If "cannot open source input file" keeps coming back after you move the project, register include paths relative to the project folder instead of absolute paths.

Flashing failures

These are debugger settings, not code.

No Algorithm found for: 08000000H - 080003FFH

No flash algorithm is registered for your device. Options for Target > Debug > Settings > Flash Download > Add, pick your device family, and check the start address and size match the part.

Flash Download failed - "Cortex-M4"

Power and probe first. A charge-only USB cable will not enumerate.
In Debug > Settings, confirm the probe reports an IDCODE. If not, it's wiring.
Previously flashed firmware may have disabled the debug pins — switch to Connect under Reset.
Still stuck: full chip erase with ST-Link Utility or STM32CubeProgrammer, then retry.

If another tool is holding the probe (CubeProgrammer, a serial monitor), µVision can't claim it. Close it first.

Simulator: access violation

*** error 65: access violation at 0x40021000 : no 'read' permission

Your code touched a peripheral register the simulator doesn't model. The code is fine; the simulator simply doesn't know that address. Either switch Debug from the simulator to a real probe, or map the region from the Debug command line:

MAP 0x40000000, 0x40030000 READ WRITE

Peripheral behaviour is never fully reproduced in simulation. Use the simulator for logic, and check hardware behaviour on the board.

A five-minute checklist when nothing makes sense

Project > Clean Target, then rebuild. Stale object files cause phantom errors.
Read only the first error.
Confirm every required .c is in the Project pane — especially the startup file.
Check Options for Target > Device against the actual part, and the define macro with it.
Open Manage Run-Time Environment and look for yellow/red markers — missing packs surface here.
Move the project somewhere without spaces or non-ASCII characters in the path. Older toolchains still trip over those.

I keep the full version of this updated here, along with a register-level embedded C track (8051 and STM32, no HAL) if you're learning this from scratch:

Guide: https://www.coding-now.com/en/guides/keil-uvision-build-errors?utm_source=devto
Embedded C lessons (free): https://www.coding-now.com/en/blog/c-embedded?utm_source=devto

Which Keil error has eaten the most of your time? If it's one I haven't listed, tell me and I'll add it with a proper explanation.

I built a portable serial terminal for ESP32/Arduino in Rust — because my board kept resetting

코딩나우(하늘아래) — Fri, 12 Jun 2026 06:36:58 +0000

If you debug ESP32 boards over serial, you probably know this one: you flash the firmware, rush to open a serial monitor to catch the boot logs… and the act of opening the monitor resets the board. The DTR/RTS lines toggle on connect, the ESP32 auto-resets, and the first lines you actually wanted are gone.

I hit this enough times that I built my own terminal.

CNTerminal
Live + download: https://www.coding-now.com/en/cnterminal Source (MIT): https://github.com/cflab2017/tool_serial_terminal_Rust

It's a free, portable serial terminal for Windows — a single ~8 MB .exe. No installer, no runtime, no admin rights: drop it on a USB stick, run it on a locked-down lab PC, done.

What it does:

DTR / RTS control — the reason it exists. Keep DTR from toggling on connect and the ESP32 doesn't auto-reset, so you actually see the boot output.
HEX send & receive — for binary protocols, plus an ASCII ↔ HEX converter built in (no more alt-tabbing to a converter site mid-debug).
5,000-line auto-trim — long logging sessions don't slowly eat your RAM or lag the UI.
The usual: port/baud selection, timestamps, a dark amber CRT theme that's easy on the eyes during long sessions.
Why Rust + egui
I wanted a single file people could run anywhere, which ruled out anything with a runtime. Rust + egui turned out to be a great fit: the whole GUI app compiles to one small native binary, immediate-mode UI keeps the serial read loop and the rendering loop simple to reason about, and serialport-rs handles the device side.

The trickiest part wasn't the UI — it was making the serial reader thread, the auto-trimmed scrollback buffer, and the GUI repaint cooperate without dropping bytes at high baud rates. If you're curious, the source is MIT and pretty small.

Honest scope
Windows only for now (single-exe portability was the goal).
It's a terminal, not an IDE plugin — it does serial I/O well and nothing else.
If you live in a serial monitor — Arduino, ESP32, STM32, industrial gear over RS-232 — give it a try and tell me what's missing compared to your current setup. Feature requests and bug reports are very welcome, here or on GitHub.

5 free dev tools I built — no signup, no ads (most run entirely in your browser)

코딩나우(하늘아래) — Tue, 02 Jun 2026 03:41:17 +0000

I got tired of "free" online dev tools that bury you in ads, make you sign up, or quietly upload your data to a server just to format some JSON or resize an image. So over the last while I built a handful of small, single-purpose tools that fix that: no signup, no ads, and the web ones do everything in your browser — nothing is uploaded.

Sharing them here in case they're useful, and I'd genuinely love feedback on edge cases. I'm the author of all of these.

Web tools (100% client-side — your data never leaves the tab)

JSON Formatter & Validator → https://www.coding-now.com/en/json-formatter Pretty-print (2/4/tab) or minify, with a collapsible color-coded tree view. The part I use most: when JSON is invalid it points to the exact line:column of the error instead of a vague "unexpected token." Safe to paste API responses with tokens in them, since nothing is uploaded.
Image Format Converter (PNG · JPEG · WebP) → https://www.coding-now.com/en/image-converter Drag an image, pick a format, tweak quality, download. Handy for shrinking PNG screenshots to WebP, or flattening transparency before a JPEG export — all in the canvas, no upload.
Audio Cutter (trim to lossless WAV) → https://www.coding-now.com/en/audio-cutter Drop an MP3/WAV/M4A/OGG/FLAC, drag a region on the waveform, preview it, and export just that slice as WAV. Great for grabbing a clip without firing up an editor.
QR Code Generator (text · URL · WiFi · vCard + logo) → https://www.coding-now.com/en/qrcode Beyond plain URLs: generate WiFi QR codes (guests scan to join) and vCard contact QR codes, drop a logo in the center, and download PNG or SVG (the SVG embeds the logo too).

Bonus — a tiny desktop one

SnapLaunch (Windows) → https://www.coding-now.com/en/snaplaunch A portable tool that adds your favorite apps to the right-click menu of the Windows desktop/folders. No admin rights, single EXE. (This one's a native app, not a web tool — including it for completeness.)

Common thread: each is small, free, and respects your data — the web ones are a single static HTML file with zero dependencies. If you find a bug or a missing feature (especially in the JSON validator's error positions), I'd really appreciate hearing it in the comments.