DEV Community: EffessDev

I Made a Video Editor Specifically for DEV.to Writers

EffessDev — Wed, 30 Sep 2026 15:46:54 +0000

How many times have you taken a screen recording and wished you could quickly crop the taskbar down there, trim the start and end so no one sees you opening OBS Studio, cut and delete the part where you fell asleep, export it as an optimized animated GIF or WebP, and drag and drop it directly to your DEV.to post?

Opening DaVinci Resolve for this purpose is overkill. Even if you open it anyway, you will not be able to crop your video like this:

In my opinion, this is the most useful feature of this app. Many video editors force you to pick a canvas resolution and won't allow you to change it this way.

But other than that, it also supports the following features (note: these features were written by Gemini):

Non-Destructive Multi-Clip Timeline:
- Split video segments anywhere (S key).
- Drag and drop clips to reorder them on the fly.
- Drag clip edges to trim start and end points with live preview.
Flexible Export Options:
- Export to WebP, GIF, MP4, WebM, MOV, or MKV.
- Adjust framerate (0.5 to 60 FPS), scaling/resolution %, and quality settings (automatic palette generation with dither controls for GIFs).
Fast Timeline Navigation & Controls:
- Scroll, zoom (Ctrl + Wheel), and pan (Middle-click drag) through complex timelines.
- Frame-by-frame navigation using arrow keys.
Seamless Preview:
- Automatic background proxy generation for codecs not natively supported by Qt.

As of now, it works, and it is useful. I have tested it quite a bit and fixed many issues. But still, it is not a polished product yet, and it requires FFmpeg to work. Installing FFmpeg is very easy. In Windows, just run winget install Gyan.FFmpeg.

I have opened a few issues myself. They contain a few things I have tried (but couldn't do), and also things that I'll add in the future:

https://github.com/effessdev/GiffyPy/issues

The app is made using Python and PySide6. Here is a link to the GitHub Repo:

https://github.com/effessdev/GiffyPy

Now, do you find this useful? Have you been through this kind of friction before while writing in DEV? I'd love to hear your thoughts!

I Let Free Web Gemini Code My Terrarium, and Now the Worms are Having an Identity Crisis

EffessDev — Mon, 28 Sep 2026 11:14:04 +0000

I built a terrarium simulation using Pygame a while back:

Let's check whether Gemini can add entirely new features to this Python codebase without blowing everything up.

Let's open up the project in VS Code:

I am using ReptClip for VS Code (an extension I built) to build the context and apply the diffs.

Let's addREADME.md, requirements.txt, and all Python files into the context (I know it's not ideal, but let's try):

Already 64,000 tokens. Let's paste it in:

What? The browser chat UI silently truncated the context I pasted in, without showing a single warning!

Luckily, the limit is larger if you upload the context as a file:

Let's type the prompt and hit send!

A 108-line diff. Now, I can copy the diffs and click Apply Diffs in my extension. It will automatically read them from the clipboard and apply the changes:

Let's try once more:

Even though ReptClip supports fuzzy matching in SEARCH blocks, the AI hallucinated too much, so the extension wasn't able to find a match.

Here is my new plan:

Give the AI only the project structure, README, and requirements.txt
Ask it which files it needs to see to implement the feature

It gave a list of the files it wants to see:

Since we already added the project structure and output format, let's uncheck them and add the files Gemini asked for:

Luckily, this time it didn't get truncated:

The new diff was 165 lines:

Let's apply the diffs:

Only one fuzzy match. Let's launch the terrarium:

There we go! We got the feature we asked for.

Time to make it harder. The new feature:

A suspiciously tiny diff that literally fits into a single screenshot:

I applied it anyway:

And ran the simulation:

The worms looked a bit different, but it was definitely far from what I asked. Let's try again with Gemini Pro.

It's using some big words:

It gave me a 265-line diff modifying 2 files. Let's see what it did.

I can't even see the worms.

I thought maybe they were still growing. I waited in front of the simulation at 8x speed for days*:

Still empty. Let's try with Gemini Extended Thinking:

According to Gemini, it found the exact bug:

I applied its recommended patch:

Still no worms.

Let me handle this alone without taking a screenshot every 5 seconds. I'll come back soon.

🏃 ...

So, according to Gemini, this was the reason:

Anyway, I gave it ant.py so it could refer to it and generate proper diffs. This time, I was able to see something!

Now THAT is what actual peristalsis looks like!

I think that's enough for now without breaking it even more.

I Built a VS Code Extension to Paste Your Project into Free Chatbots and Apply the Diffs in One Click

EffessDev — Sat, 26 Sep 2026 12:01:15 +0000

Let me show exactly how it works with an example 🛻

The extension adds a new "ReptClip" tab in the VS Code bottom panel:

I am going to use this extension to redesign my website's landing page. First, we need to prepare the context.

Specify which files to add to the context in the "Files to include" input. You can use glob patterns like **/*.ts.

Since I want to update the landing page, let's add page.tsx. You will get suggestions as you type:

Click "Enter" or "Tab" to accept the suggestion:

If it matches any files, it will turn green. Otherwise, it will turn yellow.

Let's add AGENTS.md too:

This order is preserved in the context output. page.tsx will appear after AGENTS.md.

Now, click "Enter" again. The context will be copied directly to your clipboard. It looks something like this:

# Project structure

```
.gitattributes
.gitignore
AGENTS.md
CONTRIBUTING.md
LICENSE
README.md
pipxclip-config.toml
pyproject.toml
src/pipxclip/__init__.py
src/pipxclip/cli.py
src/pipxclip/config.py
tests/test_cli.py
tests/test_config.py
```

# Output format

Provide all file modifications as Search/Replace blocks inside a single 4-backtick code block.

## Formatting Rules

1. **File Headers:** Every set of edits must begin with the exact relative file path on its own line (e.g., `path/to/file.ext`), even if there is only a single file in the project.
2. **Exact Matching:** The `SEARCH` block must contain an *exact, verbatim* copy of existing code, including identical whitespace, indentation, and surrounding context lines to uniquely identify the match.
3. **Uniqueness:** Provide sufficient surrounding unchanged lines in the `SEARCH` block to ensure it matches exactly **one** location in the target file.
4. **New Files & Deletions:**
   - To create a new file, use an empty `SEARCH` block.
   - To delete a file or a code block, use an empty `REPLACE` block.
5. **No Placeholders:** Do not use ellipses (`...`), comments like `# rest of code unchanged`, or omitted lines inside `SEARCH` or `REPLACE` blocks.
6. **Sequential Edits:** If editing multiple parts of the same file, list the `SEARCH/REPLACE` blocks in top-to-bottom order as they appear in the file.

## Example

````
src/models/user.py
<<<<<<< SEARCH
class User:
    def __init__(self, name):
        self.name = name

    def to_dict(self):
        return {"name": self.name}
=======
class User:
    def __init__(self, name, email):
        self.name = name
        self.email = email

    def to_dict(self):
        return {
            "name": self.name,
            "email": self.email,
        }
>>>>>>> REPLACE

src/controllers/user_controller.py
<<<<<<< SEARCH
from src.models.user import User
=======
from src.models.user import User
from src.utils.validator import validate_email
>>>>>>> REPLACE
<<<<<<< SEARCH
def create_user(name):
    return User(name)
=======
def create_user(name, email):
    validate_email(email)
    return User(name, email)
>>>>>>> REPLACE

src/utils/validator.py
<<<<<<< SEARCH
=======
def validate_email(email):
    if "@" not in email:
        raise ValueError("Invalid email address")
>>>>>>> REPLACE
````

# AGENTS.md

```
Do not make mistakes.
```

# Prompt

<- Cursor lands here. You can quickly start typing.

Now, go to any free chatbot and paste the context using Ctrl + V:

Type your prompt, and send:

The chatbot will generate the diffs inside a code block:

Copy it to your clipboard, and go back to VS Code.

Click "Apply Diffs" in the ReptClip tab. The extension reads the diffs from the clipboard and applies them to the files:

Let's start the development server and check out the new landing page:

The landing page has been redesigned.

If you didn't like the changes, clicking "Revert" reverts all affected files to the previous state.

If at least one of the diffs is faulty, you'll get this:

It also lets you customize the context:

State is stored on a per-project basis. So, when you come back, your configuration will not be gone or mixed up with other projects.

If you want to use the extension purely for context, uncheck Diff format to remove the ## Output format section.

Here are a few edge cases explained:

Files to include **/*.py main.py: All Python files are included, but main.py comes last.
Files to include **/*.py src/**/*.py: All Python files are included, but the Python files in src come last.
Files to include **/*.py, files to exclude secret.py: All Python files are included, except secret.py.

So, that's basically what the extension does. If you liked it, a ⭐ on GitHub would really help A LOT! Please feel free to share it with friends or teammates who are looking for a $0 AI coding setup.

It's inspired by my CLI app PipxClip, which was formerly ReptClip, so I named it ReptClip for VS Code.

Also, please tell me what you think in the comments. It really helps me improve the extension further. Big thanks to @piekwerk and @mansio for their suggestions during development!

Also, thanks to @unitbuilds for informing me about the limited-time free access to Qwen 3.8 Flash in Qoder. It wouldn't have been possible without it.

I purposefully kept the source code minimal and lightweight. Feel free to submit pull requests. I review them every day!

Total cost to build this: $0.

I created this extension specifically to help developers who can't afford paid coding agents, giving everyone access to a smooth AI workflow for free.

Thanks for reading 🙂🎉🎉

Is DEV.to Analytics broken? 🤔

EffessDev — Thu, 24 Sep 2026 12:47:37 +0000

This is the traffic sources graph for a post I created a few hours ago:

It's not just this post. Every single one of my posts is dominated by direct/unknown sources. Is it like that for everyone else in here? Or is it just me? It doesn't make any sense at all.

I Made a VS Code Extension to Copy Your Repo to Your Clipboard as Clean Markdown Context for Your Chatbot

EffessDev — Thu, 24 Sep 2026 10:11:21 +0000

⚠️ NOTE

You are reading a post about an older version of the extension. Newer versions automatically apply the generated diffs from your clipboard and add many more features. Check out the GitHub Repository for the most up-to-date details, or read this updated post on DEV.

The UI:

An example output:

# Project structure

```
.gitattributes
.gitignore
AGENTS.md
CONTRIBUTING.md
LICENSE
README.md
assets/preview.webp
docs/me/prompt.md
docs/me/publishing.md
pyproject.toml
reptclip-config.toml
src/reptclip/__init__.py
src/reptclip/cli.py
src/reptclip/cli_parser.py
src/reptclip/clipboard.py
src/reptclip/config.py
src/reptclip/file_reader.py
src/reptclip/filters.py
src/reptclip/git_files.py
src/reptclip/markdown_builder.py
tests/test_cli.py
tests/test_config.py
tests/test_file_reader.py
tests/test_filters.py
tests/test_git_files.py
tests/test_markdown_builder.py
```

# AGENTS.md

```
Do not make mistakes.
```

# Prompt

<- Cursor lands here; you can quickly start typing!

Basically, type whatever you want to copy, then press Enter. Context will be copied straight to your clipboard!

Also, you'll get suggestions as you type:

State is stored on a per-project basis. When you come back, your configuration will too!

It's inspired by my CLI app PipxClip, which was formerly ReptClip. So I named it ReptClip for VS Code.

Here are the key improvements from the CLI version:

No need to provide quotes for glob patterns: This is impossible in the CLI
Get suggestions as you type
Syntax highlighting
Intuitive UI (README not required!)

It's really useful for me because this is my workflow when I finish my GitHub Copilot free credits:

Copy files
Paste them into gemini.google.com
Paste them back

And repeat:

If you also found this helpful, please consider giving a ⭐ on GitHub! It really helps A LOT!

Thank you for reading till the end! Please let me know what you think. I am really curious!

Issues and PRs are welcome too!

I just did something my AI agents couldn't

EffessDev — Sat, 12 Sep 2026 04:30:19 +0000

It is funny how things work out. You can let AI tools try to fix a code problem for days, but nothing works until you finally step in and do it yourself.

I was working on my ESP-IDF project and wanted to organize it better. My goal was to use the standard practice of keeping different pieces of code in a folder named components.

Try #1: Gemini 3.6 Flash

I don't pay for AI, so I use the free web versions. I used a tool I built called ReptClip to copy my project structure and files. Then, I asked the AI which files to move and what new code to put inside them.

I did exactly what the AI said without questioning it. Suddenly, red error lines popped up in my code editor. Soon, the whole file was covered in errors. I told the AI about it.

It gave me new steps, and I just followed them again. It still didn't work.

I did this over and over for hours. I got very mad, called the AI stupid, and reset my working directory to start all over from scratch. I do not know why it failed at such an easy job.

Try #2: Gemini 3.1 Pro

I thought the Pro version of the AI would do a better job. I tried the exact same steps and trusted it completely again. But I ended up with the exact same errors.

Tries #3, #4, #5, ... #n

I lost count of how many times I tried this. I tested Gemini Flash Extended, Gemini Pro Extended, DeepSeek v4 Flash, and DeepSeek v4 Pro. For some reason, absolutely nothing worked. I wasted two whole days doing this.

Try #n + 1

Next, I decided to try GitHub Copilot. I gave it instructions, and it spent about 30 minutes on the task. It finally gave me a nice ✅ emoji and said it was done. I thought my problems were over.

I tried to build my project, but it failed. I looked at my code files, and there were error squiggles everywhere, just like before.

I gave up and left the project alone for a few days.

Try #n + 2

After a break, I came back with a new plan.

I went to gemini.google.com and chose the Pro model. I asked the same question. But this time, I stopped blindly pasting the whole file the AI gave me. Instead, I decided to edit the #include directives and type the CMakeLists.txt files by myself.

When I moved my code into the components folder, I noticed errors on the #include lines. I realized right away that the #include paths were the real issue. I told the AI that I could not add those specific headers. The AI said I needed to add the dependency components in REQUIRES or PRIV_REQUIRES in CMakeLists.txt. Adding those fixed a few headers, but some specific headers still failed.

Finally, I searched on Google to find out exactly which components have the definitions for those specific headers that were causing the issue. The answer was slightly different there.

I changed that one single line of code, and it finally worked! The ONLY problem was that all the AIs put the wrong component name in REQUIRES, and none of them could figure out that was the issue. It is hard to believe I wasted weeks on such a tiny problem.

I skipped over a fair bit of the debugging rabbit hole in this post because I honestly couldn't remember every single twist and turn 😅

Can I remove the AI-generated tag from my AI-generated course?

EffessDev — Tue, 08 Sep 2026 15:03:01 +0000

I recently used DeepSeek v4 Pro to generate an embedded systems course for app, game, or web developers who want to transition into low-level programming and embedded C. I wrote a hyper-specific prompt and asked the AI to first list the chapters and their content. Then I generated each chapter individually. Right now the course has 10 chapters.

Originally, I created this course for myself, and I've been actively using it. Before studying a new chapter, I paste the content back into an AI to check for factual errors. When something feels unclear or incomplete, I dig deeper by asking questions. Then integrate what I learn back into the course. Once I finish, I plan to have one of my college professors review it for any remaining issues.

To stay transparent, I added an "AI-generated" badge at the top of every chapter. But at this point, I'm questioning whether that label still fits. I've put a lot of personal effort into reviewing, correcting, and expanding the material. The phrase "AI-generated" often implies low effort or minimal human involvement, and I don't think that describes my course anymore.

So here's my question:

Is it fair to change or remove the AI-generated tag after significant human effort?

I'd love to hear how other people handle this, so I haven't asked this to an AI yet.

Getting Started with ESP-IDF in VS Code for ESP32: Development Environment Setup Guide

EffessDev — Sat, 29 Aug 2026 03:25:58 +0000

This is a step-by-step tutorial that explains how you can set up your development environment for working with ESP-IDF projects in VS Code.

Install ESP-IDF

Install EIM

Espressif Systems provides a graphical tool called EIM (ESP-IDF Installation Manager) to install ESP-IDF. Click the link below to go to the official page to download EIM:

https://dl.espressif.com/dl/eim/

Make sure you are in the "Online Installer" tab. The exact file to download depends on your system:

Windows: Download eim-gui-windows-x64.exe. Run this installer to install EIM.
Linux x64 (Ubuntu): Download and install the .deb package (eim-gui-linux-x64.deb).

Install ESP-IDF using EIM

Now that we have installed EIM, let's install ESP-IDF using it.

Open EIM.
Under "New Installation" click "Start Installation".
Under "Easy Installation", click "Start Easy Installation" to install the latest stable version of ESP-IDF with default settings.
If there are no problems, you will see the "Ready to Install" page. Click "Start Installation".

Install ESP-IDF VS Code Extension

We use this extension as a high-level wrapper for ESP-IDF. Most times, we do not use ESP-IDF directly. For example, if we need to compile our source code, we ask the extension to do it, which uses the ESP-IDF we just installed internally to to compile the source code.

Install the extension named "ESP-IDF" by "Espressif Systems" in VS Code.

Verify installation

After installing, restart VS Code. Use the shortcut Ctrl + Shift + P to open the command palette (remember this shortcut, we are going to use it a lot). Inside the command palette, search ESP-IDF. You will see many entries which start with ESP-IDF:. Those commands are provided my the ESP-IDF extension. These commands are what we use for almost everything.

Note

If you are not in an ESP-IDF project, you might see this:

No standard ESP-IDF project was found in this workspace. Do you want to activate the ESP-IDF extension anyway?

If you want to use the extension (in this case we do), you should click "Activate Anyway". Then only we can use the extension. If you mistakenly clicked "X", restart VS Code, wait for that to pop up again, and click "Activate Anyway".

Keep this in mind since you might need this in the future.

Creating a New Project

Like I said before, we are going to use the ESP-IDF: New Project command from the command palette to create the project. Press Ctrl + Shift + P to open the command palette.

From the command palette, search and click on ESP-IDF: New Project, and wait.
Select your ESP-IDF version (you might see only one version since we only installed one), and wait.
A new tab will pop up. Inside that tab, under ESP-IDF Templates select the sample_project template and click the "Create Project" button.

The tab will refresh, and you will see a form to fill in your project details. Fill in the details:

Project name: Your project name.
Project directory: Your project directory.
ESP-IDF target: esp32.
ESP-IDF board: Custom board.
Serial port: Detect.
OpenOCD configuration files: Keep the default value.
ESP-IDF component directory: Keep the input empty.

Click "Create Project" and wait again. After creation, in the new tab which pops up, click "Open Project". This will open your brand new ESP-IDF project in a fresh VS Code window.

If you are prompted to generate compile_commands.json, accept it. If not, or you mistakenly clicked "Decline", do Ctrl + Shift + P -> ESP-IDF: Run idf.py reconfigure Task, which does the same thing. compile_commands.json is essential for Intellisense to work correctly. Otherwise, you will encounter error squiggles everywhere.

If you are using Clangd instead of the Microsoft C/C++ extension, run ESP-IDF: Configure project for ESP-Clang from the VS Code command palette to make sure Clangd IntelliSense works correctly. Also, make sure both of them aren't activated at the same time, as they can interfere with each other.

Configure your project

You need to configure your project whenever you:

Start a new project (like we did now)
Adding, removing, or renaming source files
Adding or changing component dependencies
Fixing corrupted build files
Etc.

But it's safe to do again and again, even if you haven't done anything above or have any problems. Since we just created a new project, let's run it.

Like we did before, we are again going to use the command palette. Open the command palette (do you remember how?), and click Ctrl + Shift + P -> ESP-IDF: Run idf.py reconfigure Task.

This will take some time. While it's working, let's learn what it does:

Generates (or regenerates) the build files
Generates compile_commands.json, which is essential for Microsoft C/C++ Extension or Clangd to provide Intellisense
And a lot more (just know these two for now)

Let's write some code

If you look at main.c right now, you will see and empty main function:

#include <stdio.h>

void app_main(void)
{

}

Let's log "Hello world!" inside it:

#include "esp_log.h" // Add this header for logging
#include <stdio.h>

// Define a tag for your log messages
static const char *TAG = "MAIN";

void app_main(void) {
  // Log "Hello world!"
  ESP_LOGI(TAG, "Hello world!");
}

Building (compiling) the project

Like we always do, open the command palette and run

ESP-IDF: Build Your Project

This will also take some time. Be patient.

Flashing your project

Flashing is like uploading the compiled code to your ESP32. You need to physically connect the ESP32 to your computer. After doing that, run the following command from the command palette:

ESP-IDF: Flash (UART) Your Project

It will probably won't work out of the box. The fix differ dipending on your platform.

If you are using Windows

If you are on Windows, flashing might show this error:

A fatal error occurred: Could not connect to an Espressif device on any of the 1 available serial ports.

If that happens, the next time you try, press and hold the BOOT button on your board as soon as
you see Connecting.... After some time, the Connecting..... will stop and you see several outputs. Stop holding the BOOT button when you see these somewhere:

Uploading stub flasher...
Running stub flasher...
Stub flasher running.

It might require some trial and error to find out how long you will have to hold the BOOT button.

If you are using Linux (e.g., Ubuntu)

You might get this error while flashing:

A fatal error occurred: Could not open /dev/ttyUSB0, the port is busy or doesn't exist.
([Errno 13] could not open port /dev/ttyUSB0: [Errno 13] Permission denied: '/dev/ttyUSB0')

Hint: Try to add user into dialout or uucp group.

If that happens, run this command, log out, log back in (or reboot), and try flashing again:

sudo usermod -aG dialout $USER

You have to do it only once per system. Subsequent flashing will work without running this comamnd.

Monitoring the device

You should keep your ESP32 connected to your computer so that it recieves power and be running. Let's check whether the "Hello world!" got logged.

On the bottom of VS Code, you will see several icons. Find the icon which looks like a monitor and hover over it. If you see "Monitor Device" when you hover, you found the correct icon.

Click on that icon. You will see several logs popping up. These are send internally. But among those log messages you will find our Hello world:

I (258) main_task: Started on CPU0
I (258) main_task: Calling app_main()
I (258) MAIN: Hello world!   <--------------- this
I (258) main_task: Returned from app_main()

You might see different numbers than 258. That's not a problem.

So, congratulations! You just set up your computer for ESP-IDF, created a new project, wrote some code, compiled, flashed, and monitored the output! Next, you can check out the official documentation to learn more about ESP-IDF. I also have some great tutorials which you can read on my website or on DEV.to.

Tips

Using the `idf.py` command

idf.py may not be available in your terminal, but it's always available in the ESP-IDF terminal, which you can open using Ctrl + Shift + P -> ESP-IDF: Open ESP-IDF Terminal.

Adding the VS Code Configuration Folder

If you accidentally deleted/edited the .vscode folder, you can regenerate it using the Ctrl + Shift + P -> ESP-IDF: Add VS Code Configuration Folder command.

ESP-IDF Bluetooth LE (BLE) Beginner Tutorial

EffessDev — Fri, 28 Aug 2026 13:30:10 +0000

This tutorial covers the basics of how to use Bluetooth Low Energy (BLE) in your ESP-IDF project. It's based on the official documentation by Espressif Systems.

This is a practical, step-by-step tutorial, focusing on building a conceptual understanding of BLE and its basic code implementation, rather than every single feature in detail. You can follow along from the beginning to the end. After completing this, you will be able to understand the official documentation and the official example.

You can download the full final code here and the full project here, but I recommend you to write the code yourself by following this tutorial instead.

Let's start!

The Setup

I am assuming you have created an empty ESP-IDF project using the sample_project template and verified building and flashing is working properly. If you haven't already, you can check out my tutorial:

Enabling BLE in ESP-IDF

Before you can use BLE, you have to enable it using Menuconfig. There are two ways to do this.

Option 1: Using the VS Code Command Palette

Warning: Only use this option if you are developing using the ESP-IDF VS Code extension.

Click Ctrl + Shift + P to open the command palette.
Search for and select ESP-IDF: SDK Configuration Editor (Menuconfig).
Navigate to Component Config -> Bluetooth.
Check the Bluetooth box and select NimBLE - BLE only from the Host selector.

Option 2: Using the ESP-IDF terminal

Open the project configuration menu by running idf.py menuconfig
Navigate to Component config -> Bluetooth.
Enable Bluetooth by setting Bluetooth to [x] (enabled).
Select the host stack by navigating to Host and choosing NimBLE - BLE only.
Press S to save, then Q to quit.

Updating `CMakeLists.txt`

You should add PRIV_REQUIRES bt nvs_flash esp_driver_gpio in your CMakeLists.txt inside idf_component_register(), since our program requires them.

Including necessary headers

This program requires a lot of headers to be included. Update your main.c like this:

/* Includes */
/* STD APIs */
#include <assert.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>

/* ESP APIs */
#include "driver/gpio.h"
#include "esp_log.h"
#include "nvs_flash.h"
#include "sdkconfig.h"

/* FreeRTOS APIs */
#include <freertos/FreeRTOS.h>
#include <freertos/task.h>

/* NimBLE stack APIs */
#include "host/ble_hs.h"
#include "host/ble_uuid.h"
#include "host/util/util.h"
#include "nimble/ble.h"
#include "nimble/nimble_port.h"
#include "nimble/nimble_port_freertos.h"
#include "services/gap/ble_svc_gap.h"
#include "services/gatt/ble_svc_gatt.h"

/* Defines */
#define TAG "NimBLE_LED"
#define DEVICE_NAME "NimBLE_LED"

void app_main(void) {
    // Empty for now
}

You can change the TAG and DEVICE_NAME if required. TAG is just a label which we use for logging (we will use it later in the tutorial). DEVICE_NAME is how our ESP32 appears to the other devices (like our phone). Later, we are going to connect your phone to your ESP32. In your phone's "available devices" list, you will see this DEVICE_NAME.

Tips for beginners

We use #define to define macros. Macros are of two types - object-like macros and function-like macros. Here, TAG and DEVICE_NAME are object like macros. For now, let's only consider object-like macros (the ones we are using here).

How it works is that, we define DEVICE_NAME to be "NimBLE_LED" and use DEVICE_NAME like a variable in our code (e.g., we can call a function like this: setDeviceName(DEVICE_NAME)). When we compile our code, before the compilation step begins, the preprocessor literally replaces all instances of DEVICE_NAME with "NimBLE_LED", so the previous function call becomes setDeviceName("NimBLE_LED"). So, it is functionally identical to we directly using the string everywhere.

The main reason why we use it is because the exact same string "NimBLE_LED" will be used in multiple places in our code. If we use #define, we can be 100% sure that it will be identical everywhere. Also, if we want to change the name of our device, we just have to update DEVICE_NAME instead of eveywhere.

Initialize NVS Flash (Non-Volatile Storage)

The BLE stack requires NVS flash to store configurations, so it should be initialized using nvs_flash_init(). You don't need to overthink about it at this point. Just call it in the main function:

void app_main(void) {
    nvs_flash_init();
}

This function returns a return code. If the return code is 0, it means no errors. Any non-zero value means an error, and each value corresponds to a particular error. To make our code bulletproof, let's add some error handling:

void app_main(void) {
  esp_err_t ret; // To store the return code

  ret = nvs_flash_init();
  if (ret == ESP_ERR_NVS_NO_FREE_PAGES ||
      ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
    ESP_ERROR_CHECK(nvs_flash_erase());
    ret = nvs_flash_init();
  }
  if (ret != ESP_OK) {
    ESP_LOGE(TAG, "failed to initialize nvs flash, error code: %d ", ret);
    return;
  }
}

Tips for beginners

Here, esp_err_t is just an int, not some mysterious type. It's provided by esp_err.h, which we included in common.h. esp_err_t stands for "ESP Error Type". That alias was defined for code readability.

Similarly, ESP_ERR_NVS_NO_FREE_PAGES, ESP_ERR_NVS_NEW_VERSION_FOUND, etc. are also ints, which are defined in nvs.h. They are object-like macros defined using #define (just like how defined TAG and DEVICE_NAME), which means they will be replaced with their actual values (4365 and 4368 in this case) in the preprocessing step.

ESP_LOGE ("E" stands for "Error") is a function-like macro used to log errors. They are similar to object-like macros, but instead of replacing with an object, it replace with a function. ESP_LOGI is used for logging "Info".

Initialize GPIO2 output pin

Here, we are using GPIO2 because most ESP32s have an inbuilt LED for it.

void app_main() {
    // ...
    gpio_reset_pin(GPIO_NUM_2);
    gpio_set_direction(GPIO_NUM_2, GPIO_MODE_OUTPUT);
}

Initialize NimBLE stack

Call nimble_port_init() to initialize NimBLE, the software stack we are using to manage BLE.

void app_main(void) {
  // ...
  ret = nimble_port_init();
  if (ret != ESP_OK) {
    ESP_LOGE(TAG, "failed to initialize nimble stack, error code: %d ", ret);
    return;
  }
}

Here, we are reusing the ret variable we created earlier.

Initialize GAP

GAP stands for Generic Access Profile. Initializing it makes our ESP32 discoverable to other devices (e.g., our phone).

void app_main(void) {
  // ...
  BaseType_t rc = 0; // Still just an int; "rc" stands for "return code"

  ble_svc_gap_init();

  rc = ble_svc_gap_device_name_set(DEVICE_NAME);
  if (rc != 0) {
    ESP_LOGE(TAG, "failed to set device name to %s, error code: %d",
             DEVICE_NAME, rc);
    return;
  }
}

DEVICE_NAME is defined in common.h. You can change it if you want.

Initialize the GATT profile

This is the hard part. GATT stands for Generic Attribute. It defines how two connected devices package, format, and send data using a structured hierarchy of services and characteristics.

A GATT profile has one or more services, which have one or more characteristics within them, which hold data and descriptors. Each service and characteristic has a UUID. Here is a diagram showing the GATT hierarchy:

+---------------------------+
|          PROFILE          |
+---------------------------+
|                           |
|  +---------------------+  |
|  | SERVICE             |  |
|  +---------------------+  |
|  |                     |  |
|  | CHARACTERISTIC      |  |
|  |  - PROPERTIES       |  |
|  |  - VALUE            |  |
|  |  - DESCRIPTOR       |  |
|  |                     |  |
|  +---------------------+  |
|  |                     |  |
|  |  CHARACTERISTIC     |  |
|  |  - PROPERTIES       |  |
|  |  - VALUE            |  |
|  |  - DESCRIPTOR       |  |
|  |                     |  |
|  +---------------------+  |
|                           |
|  +---------------------+  |
|  | SERVICE             |  |
|  +---------------------+  |
|  |                     |  |
|  | CHARACTERISTIC      |  |  
|  |  - PROPERTIES       |  |
|  |  - VALUE            |  |
|  |  - DESCRIPTOR       |  |
|  |                     |  |
|  +---------------------+  |
|                           |
+---------------------------+

For example, you can create a "Heart Rate" service that has a "Heart Rate Measurement" characteristic, which holds the value.

Before defining our services and characteristics, let's initialize GATT:

void app_main(void) {
  // ...
  ble_svc_gatt_init();
}

Define GATT services table

Here is where we define which services and characteristics our ESP32 have which can be tweaked from our phone. Define these before (outside) the app_main function, but after the #includes:

static const ble_uuid16_t auto_io_svc_uuid = BLE_UUID16_INIT(0x1815);
static const ble_uuid16_t led_chr_uuid = BLE_UUID16_INIT(0x2A56);

static uint16_t led_chr_val_handle;
static int led_chr_access(uint16_t conn_handle, uint16_t attr_handle,
                          struct ble_gatt_access_ctxt *ctxt, void *arg);


/* GATT services table */
static const struct ble_gatt_svc_def gatt_svr_svcs[] = {
    /* Automation IO service */
    {.type = BLE_GATT_SVC_TYPE_PRIMARY,
     .uuid = &auto_io_svc_uuid.u,
     .characteristics =
         (struct ble_gatt_chr_def[]){
             {/* LED characteristic */
              .uuid = &led_chr_uuid.u,
              .access_cb = led_chr_access,
              .flags = BLE_GATT_CHR_F_WRITE,
              .val_handle = &led_chr_val_handle},
             {
                 0, /* No more characteristics in this service. */
             }}},

    {
        0, /* No more services. */
    },
};

You might wonder why we used 0x1815 as the UUID of our Automation IO service and 0x2A56 as the UUID of our LED characteristic. These short UUIDs are standardized by the Bluetooth SIG (Special Interest Group). Just like how the UNICODE value U+1F60A corresponds to the smiling face emoji (😊), 0x1815 corresponds to "Automation IO" and 0x2A56 corresponds to "Digital", meaning that any device that connects to our ESP32 will decide that this service is for pin control and I/O automation when it sees the UUID 0x1815. There are even more such standardized UUIDs with their own specific meaning. You can check the Bluetooth SIG Official List for all assigned 16-bit and 32-bit UUIDs.

Later in this tutorial, we are going to connect your phone to your ESP32, and you will see our service listed as "Automation IO". So keep this in mind.

You can also use your own UUIDs instead of these standardized UUIDs, but make sure to use a 128bit UUID instead to make sure you don't accidentally use a standardized UUID, which can be misleading.

Here, {0} acts as the null terminator. It is required to denote the end of the array.

Now we have defined the services tables. Let's define the led_chr_access callback.

Defining the Access Callback

The access callback function handles incoming requests from connected clients. Since we configured our LED characteristic with BLE_GATT_CHR_F_WRITE, NimBLE will invoke this function whenever a client (such as your phone) sends a write command.

Copy the following code below the GATT services table, but above the main function:

static int led_chr_access(uint16_t conn_handle, uint16_t attr_handle,
                          struct ble_gatt_access_ctxt *ctxt, void *arg) {
    if (ctxt->op == BLE_GATT_ACCESS_OP_WRITE_CHR) {
        // Extract the incoming byte payload
        uint8_t val = ctxt->om->om_data[0];

        if (val == 1) {
            gpio_set_level(GPIO_NUM_2, 1);
            ESP_LOGI(TAG, "LED turned ON");
        } else if (val == 0) {
            gpio_set_level(GPIO_NUM_2, 0);
            ESP_LOGI(TAG, "LED turned OFF");
        } else {
            ESP_LOGW(TAG, "Invalid payload value received: %d", val);
        }
        return 0;
    }

    return BLE_ATT_ERR_UNLIKELY;
}

Here, ctxt->op indicates what operation triggered the callback. We check if it equals BLE_GATT_ACCESS_OP_WRITE_CHR. ctxt->om points to an os_mbuf buffer structure containing the received payload data. ctxt->om->om_data[0] reads the first byte. gpio_set_level() sets the voltage of GPIO pin 2, which corresponds to the built-in LED in most ESP32s. If you don't have it, you can change the pin or connect an external LED.

Registering Services and Characteristics

Now that our GATT table and access callback are defined, we must register them with the NimBLE stack. Paste the following code in app_main():

void app_main(void) {
    // ...
    rc = ble_gatts_count_cfg(gatt_svr_svcs);
    if (rc != 0) {
        ESP_LOGE(TAG, "failed to count gatt services, error code: %d", rc);
        return;
    }

    rc = ble_gatts_add_svcs(gatt_svr_svcs);
    if (rc != 0) {
        ESP_LOGE(TAG, "failed to add gatt services, error code: %d", rc);
        return;
    }
}

Advertising

To enable smartphones or central devices to discover your ESP32, you must start advertising. Advertising is like sending the signals so that other devices (like your phone) can find your ESP32.

Define an on_sync callback function that handles advertising. You don't really need to worry about this function right now, just copy it into your file:

static void gatt_svr_on_sync(void) {
    struct ble_hs_adv_fields fields;
    memset(&fields, 0, sizeof(fields));

    // Make device discoverable and broadcast the name
    fields.flags = BLE_HS_ADV_F_DISC_GEN | BLE_HS_ADV_F_BREDR_UNSUP;
    fields.name = (uint8_t *)DEVICE_NAME;
    fields.name_len = strlen(DEVICE_NAME);
    fields.name_is_complete = 1;

    int rc = ble_gap_adv_set_fields(&fields);
    if (rc != 0) {
        ESP_LOGE(TAG, "failed to set advertising data, error code: %d", rc);
        return;
    }

    // Configure advertising behavior
    struct ble_gap_adv_params adv_params;
    memset(&adv_params, 0, sizeof(adv_params));
    adv_params.conn_mode = BLE_GAP_CONN_MODE_UND; // Undirected connectable
    adv_params.disc_mode = BLE_GAP_DISC_MODE_GEN; // General discoverable

    rc = ble_gap_adv_start(BLE_OWN_ADDR_PUBLIC, NULL, BLE_HS_FOREVER,
                           &adv_params, NULL, NULL);
    if (rc != 0) {
        ESP_LOGE(TAG, "failed to start advertising, error code: %d", rc);
        return;
    }
    ESP_LOGI(TAG, "Advertising started successfully");
}

Now, assign the sync callback in the main function so that it runs at the correct time:

void app_main(void) {
    // ...
    ble_hs_cfg.sync_cb = gatt_svr_on_sync;
}

Running the NimBLE Task

NimBLE operates asynchronously within its own FreeRTOS task context. Define a dedicated host task function:

void nimble_host_task(void *param) {
    nimble_port_run(); // Runs continuously to handle stack events
    nimble_port_freertos_deinit();
}

Start the task from the main function:

void app_main(void) {
    // ...
    nimble_port_freertos_init(nimble_host_task);
}

Now you have done the coding part. Let's test your device!

Testing Your ESP32 BLE Server

Build and flash the code to your ESP32.
Install nRF Connect on your mobile phone.
Enable Bluetooth on your phone.
Open nRF Connect and scan for nearby devices.
Select your ESP32 device using the provided name (DEVICE_NAME) and tap Connect.
Locate the Automation IO service (0x1815).
Select the Digital characteristic (0x2A56) and tap the Write action.
Send a payload of 01 (type = BYTE) to turn GPIO2 High (LED ON), or send 00 to switch it Low (LED OFF).

If your LED responded, congrats! You just successfuly created a bluetooth-controlled IoT device and controlled it using your phone!

What's Next

Now you have built the foundations of BLE. To learn more about BLE, check out the official documentation and the official example. Since you now know the basic concepts, the docs will feel much easier to digest.

If you found this tutorial helpful, please let me know!

I Built an AI Memory App That Lets You See, Edit, and Control Everything It Remembers

EffessDev — Fri, 21 Aug 2026 16:02:42 +0000

Ever forgotten when you last had a tetanus vaccine? Or what your blood test results were from two years ago?

I ran into this problem myself, so I built MmOrganized - an AI-powered memory app that gives you full visibility and control over what the AI remembers about you.

The Problem with Default AI Memory

ChatGPT and Gemini both have memory features now, which is great. But they have a specific limitation: you cannot (easily) see what they remember, edit mistakes, or delete incorrect information. You are essentially trusting a black box to store your personal data accurately.

For something as critical as health information, this was a dealbreaker for me. I needed to know exactly what was being stored and be able to fix it if something was wrong (I'm not saying the ChatGPT/Gemini memory is bad; they are just meant for a different purpose).

How MmOrganized Works

The app uses a familiar chat interface. You sign up with your Google or GitHub account, and you are ready to go. The concept is simple:

You type anything you want the AI to remember. For example, you can say "I took a tetanus vaccine today" or "My blood pressure was 120/80 yesterday". The AI processes your input and saves it to your personal memory store.

When you need to retrieve that information later, you switch to Recall mode with a single tap and ask naturally: "When did I last get a tetanus shot?" The AI searches your memory and gives you an immediate answer. You can even continue the conversation with follow-up questions.

Full Control Over Your Memories

This is where MmOrganized differs from other AI memory solutions. You can:

View everything - Every single memory the AI has saved about you is displayed exactly when it gets inserted, along with a handy delete button. Nothing passes in without you knowing.
Manual control - Add, edit, search, and reorder memories completely manually if you want.
Delete your data - Permanently delete your entire account and data whenever you want.

Full Data Portability with Text Files

One of the most important features is the import and export functionality. You can download your entire memory as a simple text file. This is not some proprietary format that locks you in. It is plain text that you can open in Notepad, edit with any text editor, or even copy and paste into another chatbot.

You can then upload it back to MmOrganized with options to either replace your existing memory or append the new content. This gives you complete ownership of your data. You are never locked into the platform.

The Technology Behind It

It's a full-stack Next.js app, using Shadcn UI, Drizzle ORM, Motion, Better Auth, Pusher, etc. I have also built a few custom components and animations to give some character to the site.

Notifications

I also gave the AI the ability to send you notifications. Not particularly useful, but cool. But notifications in general have other purposes.

What Comes Next

This currently does everything I want it to do, so I am unsure what to add next. What would make this more useful for you? What features are currently missing? Please try it out and let me know what you think below.

Also, my first video edit, just go easy on me 🥺

Link: https://mmorganized.vercel.app

(Note: This is an older project that I personally still use heavily. It's not under active development because it already checks all my personal boxes. But if you have a killer feature idea, I will definitely consider it!)

Change touchpad scroll speed in Ubuntu (no terminal, easiest & fastest method)

EffessDev — Sat, 08 Aug 2026 12:33:12 +0000

Here is how you can reduce the two-finger touchpad scroll speed in Ubuntu without using the terminal.

Step 1: Install Wayland Scroll Factor

Go to the official release page: https://github.com/daniel-g-carrasco/wayland-scroll-factor/releases/tag/v1.0.0
Scroll down to the "Assets" section and click wayland-scroll-factor_1.0.0-1_amd64.deb to download it.
Double-click the downloaded file. A new "App Center" window will open.
Click "Install" to install the app.

Step 2: Launch the app

Open the Wayland Scroll Factor app:

Step 3: Adjust

Adjust the speed using the sliders.

Installing in other operating systems

Visit https://github.com/daniel-g-carrasco/wayland-scroll-factor.

DEV Community: EffessDev

I Made a Video Editor Specifically for DEV.to Writers

I Let Free Web Gemini Code My Terrarium, and Now the Worms are Having an Identity Crisis

I Built a VS Code Extension to Paste Your Project into Free Chatbots and Apply the Diffs in One Click

Is DEV.to Analytics broken? 🤔

I Made a VS Code Extension to Copy Your Repo to Your Clipboard as Clean Markdown Context for Your Chatbot

I just did something my AI agents couldn't

Try #1: Gemini 3.6 Flash

Try #2: Gemini 3.1 Pro

Tries #3, #4, #5, ... #n

Try #n + 1

Try #n + 2

Can I remove the AI-generated tag from my AI-generated course?

Getting Started with ESP-IDF in VS Code for ESP32: Development Environment Setup Guide

Install ESP-IDF

Install EIM

Install ESP-IDF using EIM

Install ESP-IDF VS Code Extension

Verify installation

Note

Creating a New Project

Configure your project

Let's write some code

Building (compiling) the project

Flashing your project

If you are using Windows

If you are using Linux (e.g., Ubuntu)

Monitoring the device

Tips

Using the idf.py command

Adding the VS Code Configuration Folder

ESP-IDF Bluetooth LE (BLE) Beginner Tutorial

The Setup

Enabling BLE in ESP-IDF

Option 1: Using the VS Code Command Palette

Option 2: Using the ESP-IDF terminal

Updating CMakeLists.txt

Including necessary headers

Tips for beginners

Initialize NVS Flash (Non-Volatile Storage)

Tips for beginners

Initialize GPIO2 output pin

Initialize NimBLE stack

Initialize GAP

Initialize the GATT profile

Define GATT services table

Defining the Access Callback

Registering Services and Characteristics

Advertising

Running the NimBLE Task

Testing Your ESP32 BLE Server

What's Next

I Built an AI Memory App That Lets You See, Edit, and Control Everything It Remembers

The Problem with Default AI Memory

How MmOrganized Works

Full Control Over Your Memories

Full Data Portability with Text Files

The Technology Behind It

Notifications

What Comes Next

Change touchpad scroll speed in Ubuntu (no terminal, easiest & fastest method)

Step 1: Install Wayland Scroll Factor

Step 2: Launch the app

Step 3: Adjust

Installing in other operating systems

Using the `idf.py` command

Updating `CMakeLists.txt`