A couple of years ago I heard Dr. Chris Palmer on a podcast talking about the relationship between diet and mental health. It was so interesting that I bought his book *Brain Energy*. The thesis is fascinating: **the ketogenic diet can have a direct impact on your brain, your energy, and your mood**. Not just for losing weight — for functioning better.

I decided to try it. And what happened surprised me.

Within a few weeks I noticed changes I wasn't expecting:

* **the depression went away** — not gradually, it just stopped being there,
* my gums stopped bleeding (something I'd dealt with for years),
* unlimited energy throughout the day,
* better performance in sports,
* better sleep,
* better mood overall,
* the clearest head I've ever had.

I'm not a doctor and I'm not going to tell you keto is for everyone. But for me it was a before and after. And when something changes your life like that, you want to keep doing it right.

### The problem: tracking on keto is a pain

That's where the frustration started. Every tracking app follows the same formula: **search through an infinite database, pick the exact brand, guess the portion size, repeat for every ingredient**. A simple lunch could take five minutes to log. Five minutes that nobody has.

I talked to several people who also do keto and the complaint was always the same:

* "I stopped tracking because it took too long,"
* "I just eyeball everything now,"
* "the apps feel like they were made for bodybuilders, not for me."

### ChatGPT showed me the way

One day I was tracking what I ate and it occurred to me to ask ChatGPT: "I had two eggs with avocado and coffee with butter, what are the macros?" It gave me the answer in seconds. No database searching, no filling out forms, no selecting brands.

**It was ridiculously easy.**

I started doing it every day. The problem is that ChatGPT doesn't save your information. It doesn't track your progress. It doesn't tell you how many net carbs you've had today. Every conversation starts from zero.

And that's when I thought: **what if I could have the best of both worlds?** The ease of talking to an AI like it's a person, but with the real tracking of an app that saves everything, shows your progress, and keeps you in control.

### That's how KetoLuna was born

I built the app around that idea. Logging a meal should take **five seconds, not five minutes**. You have three ways to do it:

* **Take a photo** — snap your plate, the AI identifies the food, estimates portions, and calculates your macros. Done.
* **Type it naturally** — write "coffee with almond milk and two scrambled eggs" and it just works. No databases.
* **Use your voice** — tap the mic and say what you had. Same result.

The AI breaks everything down, shows you the macros, and you hit save. That's it.

**Website:** [ketoluna.vercel.app](https://ketoluna.vercel.app)

### Designed for keto from day one

Most tracking apps treat keto as an afterthought. KetoLuna was designed around it:

* **Net carbs are always front and center** — not buried in a submenu.
* **The progress ring shows your remaining carbs** — one glance and you know where you stand.
* **Quick chips** let you re-log your frequent meals with a single tap — because let's be honest, we all eat the same breakfast most days.

Beyond food, you can also track weight, blood sugar, and activities — all in the same feed, the same clean interface.

### Why I built it for women

When I started researching the keto app market, I found **thousands of options**. Literally. Competing head-on against MyFitnessPal or Carb Manager is nearly impossible — they've been around for years, have millions of users, and massive budgets.

But I noticed something: **almost no app was designed with women in mind**. Most of them feel aggressive, clinical, made for the gym bro counting every gram of protein. And there's a huge community of women doing keto who don't feel represented by those apps.

So I decided to focus KetoLuna on that niche. The design is warm, with earth tones, no intimidating charts. The experience feels friendly, not like a chore. Because **an app you actually enjoy opening is an app you'll keep using**. And in keto, consistency is everything.

### Available now

KetoLuna is on the [App Store](https://apps.apple.com/app/ketoluna-ai-keto-for-women/id6760356378) and [Google Play](https://play.google.com/store/apps/details?id=com.vexilo.ketoluna). It's free during the beta — no credit card, no trial period, no catch.

I'm actively working on it and shipping updates constantly. My goal is to make it **the best keto tracking experience out there**, and I genuinely mean that.

If you're doing keto (or thinking about starting), I'd love for you to try it and tell me what you think. Any feedback helps — I read everything.

KetoLuna: AI-powered keto tracking that doesn't waste your time

A few months ago, during a race here in Mexico City, I ran into the same problem as always: **I know photographers took pictures of me, but afterwards I have no idea where to find them**.  
One photographer gave me a card, another told me to look them up on Instagram, another had a weird URL… and of course I forgot everything a couple days later.

I talked with several runners and everyone said basically the same:  
- “I follow some photographers, sometimes I show up there,”  
- “if a friend sees my photo, they send it to me,”  
- “I search through hashtags but it takes forever.”

And I thought: **this should really be solved by now**.

### Looking for solutions (spoiler: didn’t find one I liked)

I started checking what platforms photographers use. Many use things like LumePic or PhotoHawk.  
Honestly, I went in looking for some *alternative to LumePic* or an *alternative to PhotoHawk* that felt more modern… but nothing really convinced me.

They felt **hard to use**, kind of outdated, slow, and not really taking advantage of modern tools like proper facial recognition or smart filters. They work, but it feels like visiting a website frozen in 2014.

### So… I ended up building it myself

And that’s how ZebraSnap was born.

### What is ZebraSnap?

It’s a platform where photographers upload photos from sports events, and runners can easily find themselves using:  
- their bib number,  
- facial recognition,  
- shirt color,  
- approximate time they passed,  
- and other filters that actually make sense.

Instead of chasing photographers across Instagram, you just search and you’re done.

**Website:** [https://zebrasnap.com](https://zebrasnap.com)

### Tested in real events

We tested ZebraSnap in several races with photographers who trusted the idea. Everything worked smoothly:  
- photographers were happy,  
- runners found their photos quickly,  
- and the platform didn’t explode (bonus point for me).

That was the signal that it was ready to launch.

### What's next

I’m working on the mobile app and want to release it before the end of the year. My goal is simple: **make ZebraSnap the best platform out there**, in speed, usability, and technology for race photos.

If you run or photograph sports events, I’d love for you to try it and tell me what you think. Any feedback is welcome, seriously.

ZebraSnap: the simple way to buy & sell race photos

In this post, I will show you how to send notifications via Telegram using Laravel in a simple and easy-to-configure way.

## Steps to Follow

### 1. Create Your Bot in Telegram

1. **Start a Conversation with BotFather**: Go to Telegram and search for [@BotFather](https://core.telegram.org/bots#6-botfather).
2. **Create a New Bot**: Use the `/newbot` command and follow the instructions.
   
   ```plaintext
   /newbot
   ```

3. **Assign a Name**: Choose a unique name for your bot, such as `mysuperbot9000_bot`. It must end with `_bot`.
4. **Get the Token**: You will receive a token similar to `1234567890:AAG2eDLduCRjsgHlms1EezWoCqBlpsSJexE`. Keep it safe, as you will need it later.

### 2. Configure Laravel

1. **Install the Required Package**: Use Composer to install "Telegram Notifications Channel for Laravel".

   ```bash
   composer require laravel-notification-channels/telegram
   ```

2. **Configure the Token**: Add the received token in the `config/services.php` file.

   > **Note**: Only follow these first two steps from the repository. The other steps are not necessary for our approach that uses a webhook.

### 3. Add `telegram_user_id` to the User

1. **Edit the User Migration or Create Migration**: Add the `telegram_user_id` column to the users table. For example:

   ```php
   // database/migrations/2014_10_12_000000_create_users_table.php
   public function up(): void
   {
       Schema::create('users', function (Blueprint $table) {
           // Rest of the columns…
           $table->string('telegram_user_id')->nullable();
       });
   }
   ```

### 4. Create the Controller for the Webhook

1. **Handling Telegram Messages**: The controller will process the messages received, extracting the Telegram user ID and associating it with the corresponding user in your system.

```php
<?php

declare(strict_types=1);

namespace App\Http\Controllers;

use App\Models\User;
use Illuminate\Contracts\Encryption\DecryptException;
use Illuminate\Http\Request;
use Illuminate\Support\Arr;

class TelegramBotWebhookController extends Controller
{
    public function __invoke(Request $request)
    {
        // Extracts the text of the message received from the Telegram webhook
        $message = Arr::get($request->all(), 'message.text');

        // Extracts the Telegram user ID who sends the message
        $telegramUserId = Arr::get($request->all(), 'message.from.id');

        // Extracts the code after the '/start' command and cleans it of spaces
        $code = trim(Arr::get(explode('/start', $message ?? ''), 1, ''));

        // If there's no code or the Telegram ID is null, end execution
        if (strlen($code) === 0 || $telegramUserId === null) {
            return ['success' => true];
        }

        try {
            // Tries to decrypt the received code
            $decryptedCode = decrypt($code);

            // Checks if the decrypted code complies with the format 'code:{userid}'
            if (preg_match('/^code:(\d+)$/', $decryptedCode, $matches)) {
                // Extracts the user ID from the code
                $userId = $matches[1];

                // Searches for the user in the database using the extracted ID
                $user = User::find($userId);

                // If the user is found, assigns the Telegram ID and saves the change
                if ($user !== null) {
                    $user->telegram_user_id = $telegramUserId;
                    $user->save();
                }
            }
        } catch (DecryptException $e) {
            // In case of an error in decryption, no action is taken
            // (you can add custom error handling here if you wish)
        }

        // Returns a success response
        return ['success' => true];
    }
}

```

2. **Route in Laravel**: Add a route for the webhook in `routes/web.php`.

```php
use App\Http\Controllers\TelegramBotWebhookController;
// ...rest of the routes
Route::post('telegram/webhook', TelegramBotWebhookController::class)->name('telegram.webhook');
```

3. **Exclude from CSRF**: In `app/Http/Middleware/VerifyCsrfToken.php`, add the webhook route to the exceptions.

```php
class VerifyCsrfToken extends Middleware
{
    protected $except = [
        // Add this:
        'telegram/webhook',
    ];
}
```

### 5. Configure the Webhook in Telegram

1. **Create Command in Laravel**: Create a command that sets up the webhook for

 your Telegram bot.

```php
<?php

declare(strict_types=1);

namespace App\Console\Commands;

use Illuminate\Console\Command;
use Illuminate\Support\Facades\Http;
use NotificationChannels\Telegram\Telegram;

class ConfigureTelegramWebhoook extends Command
{
    /**
     * The name and signature of the console command.
     *
     * @var string
     */
    protected $signature = 'notifications:set-telegram-webhoook';

    /**
     * The console command description.
     *
     * @var string
     */
    protected $description = 'Set the Telegram webhook for the bot';

    /**
     * Execute the console command.
     */
    public function handle()
    {
        $telegram = app(Telegram::class);

        // The `Telegram` class doesn't have a method to set the webhook so we will just
        // use it to get the api url and the token
        $apiUri = sprintf('%s/bot%s/%s', $telegram->getApiBaseUri(), $telegram->getToken(), 'setWebhook');

        Http::post($apiUri, [
            'url' => route('telegram.webhook'),
        ]);

        $this->info(sprintf('Telegram webhook configured to %s !', route('telegram.webhook')));
    }
}

```

**Note**: Make sure the webhook route is publicly accessible. If you're working locally, tools like [expose](https://expose.dev/) can be helpful.

2. Run the command you just created `php artisan notifications:set-telegram-webhoook`

3. If everything works correctly, you should be able to see that the `telegram_user_id` is correctly assigned in your database.

### 6. Test the Webhook

1. **Generate Encrypted Code**: Use `php artisan tinker` to generate an encrypted code that associates a user ID with your bot (in a real application you would probably generate this code and give it to the user to copy).

```bash
encrypt('code:1') // Replace '1' with the desired user ID
```

2. **Send Message to the Bot**: Use the generated code to send a message to your bot in the format `/start {encrypted_code}`.

Example:
```plain
start eyJpdiI6Im1iZzNVZkxUTlMxUGVESlNmdkE0bFE9PSIsInZhbHVlIjoiSDBoVytqOWxuZUNvZjJzaEZEY3paRjJGcmxNYkF2a2x5Q0tteW9vejJ1OD0iLCJtYWMiOiI4ZDU3Mzg0OGQ0YmMwOTM3MzMxMTI1Y2E1OGI2ODFlNTJlM2E0NjdmMzFlMjAwMGVlMDVkZmM5ZDZmYTVhZTJkIiwidGFnIjoiIn0=
```

### 7. Send a Test Notification

1. **Create a Notification**: Use the following example notification to test that you receive messages.

```php
<?php

declare(strict_types=1);

namespace App\Notifications;

use App\Enums\NotificationChannelEnum;
use App\Models\User;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Notifications\Notification;
use NotificationChannels\Telegram\TelegramMessage;

class TestNotification extends Notification implements ShouldQueue
{
    use Queueable;


    /**
     * Get the notification's delivery channels.
     *
     * @return array<int, string>
     */
    public function via(User $notifiable): array
    {
        return ['telegram'];

    }

    public function toTelegram(User $notifiable)
    {
        // Content with markdown formatting
        $content = sprintf("*%s*\n\n%s", 'Test notification!', 'If you see this message, it means that your notification was sent successfully.');

        return TelegramMessage::create()
            ->to($notifiable->telegram_user_id)
            ->content($content);
    }
}

```

2. **Test the Notification**: In the Laravel console, send a test notification.

 `php artisan tinker`

```bash
User::find(1)->notifyNow(new App\Notifications\TestNotification())
```

You should receive a notification from your bot on Telegram.

Sending Notifications on Telegram with Laravel, the Easy Way

To automatically run laravel pint in VS Code when saving PHP files, follow these steps:

1. Install the `emeraldwalk` ["Run on Save"](https://marketplace.visualstudio.com/items?itemName=emeraldwalk.RunOnSave) extension from the VS Code Extensions Marketplace.

2. In your `settings.json` file, Configure the "Run on Save" extension to run the pint command every time you save a PHP file :
   
```json
   "emeraldwalk.runonsave": {
	  "commands": [
		{
		  "match": "\\.php$",
		  "cmd": "${workspaceFolder}/vendor/bin/pint ${file}"
		}
	  ]
	}
```

3. Open a PHP file in your Laravel project, make a change, and save it (`Ctrl+S`).

4. Witness the `php artisan pint` command's output in the terminal at the bottom of the VS Code window.

Run Laravel Pint on Save with VS Code

In this quick tutorial, we'll show you how to list the recent GitHub branches in your terminal using a simple command, and how to create an alias for that command to save time and streamline your workflow.

### Listing Recent GitHub Branches

To list the 20 most recent branches in your local repository, enter the following command in your terminal:

```console
git for-each-ref --count=20 --sort=-committerdate refs/heads/ --format='%(refname:short)'
```
*This command will display the 20 most recent branches, sorted by the commit date in descending order.*


### Creating an Alias for the Command

To make the process even more efficient, you can create an alias for the command. Add the following line to your `.bashrc`, `.zshrc`, or other relevant shell configuration file:

```console
alias rb="git for-each-ref --count=20 --sort=-committerdate refs/heads/ --format='%(refname:short)'"
```

After saving the changes to the configuration file, restart your terminal or run source ~/.bashrc, from now on you should be able to list your recent branches using the alias `rb`

Posts

KetoLuna: AI-powered keto tracking that doesn't waste your time

ZebraSnap: the simple way to buy & sell race photos

Sending Notifications on Telegram with Laravel, the Easy Way

Run Laravel Pint on Save with VS Code

List Recent GitHub Branches in Terminal