In a world where 89% of Indians report experiencing stress, yet seeking help remains deeply stigmatized, a Bengaluru-based product studio has found an unexpected solution: combining artificial intelligence with India’s rich spiritual heritage.

Meet Deva AI—a personal spiritual companion app that’s quietly revolutionizing how millions of Indians engage with spirituality, mental wellness, and daily guidance.

The Problem: A Generation Caught Between Tradition and Modernity

Young professionals like Anjali, a 28-year-old marketing manager, wake up to mounting work pressure, relationship anxieties, and the overwhelming question: “How do I navigate this modern chaos while staying true to my roots?”

Students like Rohan face career uncertainty and societal expectations that leave them feeling directionless. Meanwhile, seekers like Mr. Sharma find traditional religious practices either inaccessible in their busy lives or unable to provide answers for their specific, contemporary problems.

The core issue isn’t a lack of spirituality—India remains one of the world’s most spiritual nations. It’s the delivery mechanism. How do you make ancient wisdom accessible, engaging, and relevant for someone scrolling through their phone at 11 PM, feeling lost?

Enter Deva: Your Pocket-Sized Spiritual Ecosystem

Developed by BloomSynth Product Studio, Deva AI isn’t just another meditation app. It’s a comprehensive spiritual platform that combines multiple engagement touchpoints:

1. Talk to God—Literally

At the heart of Deva is its breakthrough feature: AI-powered conversations with divine personas. Users can chat with Lord Ganesha for overcoming obstacles, seek Krishna’s wisdom for relationship guidance, or find Durga’s fierce empowerment when facing injustice.

Each deity persona is carefully crafted—Ganesha speaks with warmth and encouragement, Shiva offers transformative depth, and Krishna uses his characteristic playful wisdom. The AI is trained on scriptures and Puranic stories, ensuring authentic guidance rooted in tradition.

2. Daily Spiritual Rituals, Gamified

Deva transforms ancient practices into engaging daily habits:

• Virtual Pooja: Interactive prayer experiences with drag-and-drop diyas and virtual bells
• Guided Meditations: Professional audio sessions in authentic Indian voices
• Bhagavad Gita Study: One shloka per day with translations in 6 languages and audio narration

3. The Karma Points System

Here’s where Deva’s genius truly shines. By gamifying spiritual practice, they’ve created a habit-forming loop that respects tradition while embracing modern engagement mechanics. Users earn Karma Points for daily activities, which can unlock deeper content—creating a rewarding journey of spiritual growth.

The insight? “Talking to God will always be free. We monetize devotion, not access.”

The Traction: Early Signs of Product-Market Fit

Since launch, Deva AI has achieved remarkable growth in less than three months:

• 10,000+ downloads on the Google Play Store
• 4.7-star average rating
• Highly engaged power users who return daily for meditation, pooja, and divine conversations
• Qualitative feedback showing users feel genuine connection and find real value

Perhaps most tellingly, these numbers came with minimal marketing—suggesting strong word-of-mouth and organic discovery. Reaching 10K downloads in under 90 days signals genuine product-market fit in a crowded app marketplace.

The Business Model: Freemium 2.0

Unlike subscription-heavy wellness apps, Deva uses a gamified monetization strategy that respects the user’s spiritual journey:

• Free Path: Earn Karma Points through daily activities to unlock content
• Paid Path: In-app purchases to accelerate progress without waiting

The model avoids subscription barriers while converting passionate users into paying customers—and early signs suggest it’s working.

Why Deva Could Be a Category Winner

1. First-Mover Advantage: Deva is pioneering “Gamified Spiritual Wellness”—a category that didn’t exist before.

2. Deep Cultural Fit: By respecting India’s spiritual diversity (10 deity personas, 6 languages, authentic scriptural grounding), Deva feels like our app, not a Western import.

3. The Engagement Moat: Competitors offer content. Deva offers experiences. The daily ritual loop creates genuine habit formation.

4. Expanding Addressable Market: With 250+ million digitally-savvy Indians aged 18-60, and increasing smartphone penetration in Tier 2/3 cities, the TAM is massive and growing.

The Bottom Line

In a market where stress is pervasive, traditional therapy is stigmatized, and spiritual guidance feels inaccessible, Deva AI has found a white space that’s both massive and deeply human.

They’re not just building an app—they’re creating a movement where technology doesn’t replace tradition but rather makes it radically more accessible.

For investors looking at India’s next wave of consumer tech, this is worth watching. For users seeking guidance, the Deva app is worth downloading.

Sometimes the most innovative solutions come from honoring what’s ancient while embracing what’s possible.

Deva AI is available on the Google Play Store. To learn more about BloomSynth Product Studio, visit bloomsynth.com.

The post How this Bengaluru Startup Deva AI is Reimagining Spiritual Wellness appeared first on Coding is Love.

What is Medusa?

Medusa is an open-source headless commerce engine that enables developers to create unique and scalable e-commerce experiences. Unlike traditional e-commerce platforms, Medusa offers:

• Headless Architecture: Complete freedom in frontend implementation
• Extensible Core: Plugin system for custom functionality
• Developer-First: Built with TypeScript and modern development practices
• Multi-Region Support: Built-in multi-currency support based on region
• Order Management: Comprehensive order lifecycle handling
• Inventory Management: Built-in inventory and variant management
• Modular architecture

Why React Native?

React Native is a framework for building native mobile applications using React:

• Native Performance: Direct access to native platform capabilities
• Code Reusability: Share logic between iOS and Android
• Large Ecosystem: Extensive library of third-party packages
• Hot Reload: Fast development with instant feedback
• Strong Community: Active development and community support

Using React Native with Medusa

Combining React Native and Medusa.js creates powerful mobile e-commerce possibilities:

• Native Mobile Experience: Build a React Native Medusa app with native UI components
• Mobile-First Features: Leverage device capabilities like push notifications
• Offline Support: Implement AsyncStorage for cart and user data
• Performance Optimization: Native rendering for smooth product browsing
• Cross-platform support: Build an Android and iOS e-commerce mobile app using a single code base

Introducing Medusa Mobile

Medusa Mobile is a complete React Native Medusa starter. It is not just a starter, it comes with 90% of the functionality that you need for a production-ready app.

Features of Medusa Mobile:

• 🛍️ Product browsing with infinite scroll
• 👤 User authentication and profile management
• 🔍 Categories and collections
• 🛒 Cart management
• 🏃‍♂️ Guest checkout
• 📦 Order tracking
• 🎨 Multiple themes with dark mode

Setting up Medusa Backend

Before running the mobile app, you need a Medusa backend. Set it up in a few steps by following the official docs – Install Medusa backend application

Setting up Medusa Mobile

Now let’s set up the React Native Medusa mobile app

📋 Prerequisites

Before you begin, ensure you have:

• Node.js (v20 or newer)
• React Native development environment – Set Up Your Environment
• A running Medusa v2 backend server – Medusa v2 installation

Step 1: Environment Setup

1. Clone the repository:

git clone [email protected]:bloomsynth/medusa-mobile-react-native.git medusa-mobile
cd medusa-mobile

2. Install dependencies:

npm install

3. Configure environment variables:

cp .env.template .env

Edit .env with your Medusa backend URL and publishable API key.

NOTE: Update the MEDUSA_BACKEND_URL in your .env file. If you set the URL as localhost, then the Android emulator will not be able to connect to the server. Use your local IP address instead. example: http://192.168.1.100:9000 Run ipconfig to get your local IP address.

Step 2: Start Metro Server

npm start

Step 3: Run the Application

For Android:

npm run android

For iOS: Install dependencies for iOS:

npx pod-install ios

Run the application:

npm run ios

📱 Expo Usage

This project uses React Native CLI to ensure maximum flexibility for all developers. However, Expo users are more than welcome! You can easily add Expo support with a single command.

Learn more about migrating to Expo CLI

📁 Project Structure

app/
├── screens/       # Screen components
├── components/    # Reusable UI components
├── data/          # Data context providers
├── styles/        # Theme and style utilities
├── utils/         # Helper functions
└── api/           # API client configuration

📖 Developer Guide

Here’s the documentation for managing the core functionality of the app.

🛒 Cart Management

The cart functionality is provided through the useCart hook, which gives you access to cart operations and state.

Basic Usage

import { useCart } from '@data/cart-context';

function MyComponent() {
  const { 
    cart,                // Current cart state
    addToCart,          // Add items to cart
    updateLineItem,     // Update item quantity
    removeLineItem,     // Remove item from cart
    applyPromoCode,     // Apply discount code
    removePromoCode,    // Remove discount code
    setShippingMethod   // Set shipping option
  } = useCart();
}

Working with Cart Items

1. Add a product to the cart:

const { addToCart } = useCart();

// Quantity is required when adding items
await addToCart(variantId, 1); // Add one item
await addToCart(variantId, 3); // Add three items

2. Update item quantity:

const { updateLineItem } = useCart();

// Update to specific quantity
await updateLineItem(lineItemId, 2);

// Remove item by setting quantity to 0
await updateLineItem(lineItemId, 0);

Managing Promotions

const { applyPromoCode, removePromoCode } = useCart();

// Apply a promotion code
const success = await applyPromoCode('SUMMER2024');

// Remove a promotion code
await removePromoCode('SUMMER2024');

Shipping Methods

const { setShippingMethod } = useCart();

// Set shipping method
await setShippingMethod(shippingMethodId);

Accessing Cart Data

const { cart } = useCart();

// Get cart items
const items = cart.items;

// Get cart totals
const {
  subtotal,
  tax_total,
  shipping_total,
  discount_total,
  total
} = cart;

// Check applied discounts
const appliedPromotions = cart.promotions;

// Get selected shipping method
const currentShipping = cart.shipping_methods?.[0];

Cart Lifecycle

The cart system handles various states and transitions:

1. Cart Creation:

const { cart } = useCart();

// Cart is automatically created when needed
// You don't need to explicitly create a cart

2. Guest to Customer Cart Transfer:

// When a guest user logs in, their existing cart is 
// automatically associated with their customer account
// This is handled by the CartProvider and CustomerProvider

import { useCustomer } from '@data/customer-context';
import { useCart } from '@data/cart-context';

function CheckoutFlow() {
  const { customer } = useCustomer();
  const { cart } = useCart();
  
  // Cart remains the same, only the customer_id is updated
}

3. Cart update on region change:

import { useRegion } from '@data/region-context';
import { useCart } from '@data/cart-context';

function MyComponent() {
  const { region } = useRegion();
  const { cart } = useCart();

  // Cart automatically updates when region changes
  // Product prices will be updated based on the region
  console.log(cart.region_id); // Current region ID
  console.log(cart.currency_code); // Region's currency
}

🌍 Region Management

The region functionality is provided through the useRegion hook, which handles region selection and persistence.

Basic Usage

import { useRegion } from '@data/region-context';

function MyComponent() {
  const {
    region,             // Current selected region
    setRegion,          // Update region state
  } = useRegion();
}

Working with Regions

1. Access current region:

const { region } = useRegion();

// Get region details (if region is loaded)
const {
  id,
  name,
  currency_code,
  countries
} = region || {};

2. Change region:

const { setRegion } = useRegion();

// Fetch region data first
const { region: newRegion } = await apiClient.store.region.retrieve(regionId);

// Update region
setRegion(newRegion);
// This will:
// - Persist region selection
// - Update cart region automatically
// - Trigger price recalculations

Region Selection UI

The app provides a built-in region selector modal:

import { useNavigation } from '@react-navigation/native';

function MyComponent() {
  const navigation = useNavigation();
  
  // Open region selector modal
  const openRegionSelect = () => {
    navigation.navigate('RegionSelect');
  };
}

Working with Countries

The app provides a dedicated hook for accessing region countries:

import { useCountries } from '@data/region-context';

function AddressForm() {
  const countries = useCountries();
  
  // Format countries for picker/selector
  const countryOptions = countries?.map(country => ({
    label: country.display_name,
    value: country.iso_2
  }));
}

Region Persistence

Region selection is automatically persisted using AsyncStorage:

• On first load, defaults to the first available region
• On subsequent loads, restores the previously selected region
• Region ID is stored under the ‘region_id’ key

👤 Customer Management

The customer functionality is provided through the useCustomer hook, which handles authentication and customer data management.

Basic Usage

import { useCustomer } from '@data/customer-context';

function MyComponent() {
  const {
    customer,           // Current customer data
    login,             // Login with email/password
    logout,            // Logout current customer
    register,          // Register new customer
    refreshCustomer,   // Refresh customer data
    updateCustomer     // Update customer details
  } = useCustomer();
}

Authentication

1. Login:

const { login } = useCustomer();

try {
  await login(email, password);
  // On successful login:
  // - JWT token is stored in AsyncStorage
  // - Customer data is fetched
  // - Cart is associated with customer
} catch (error) {
  // Handle login error
}

2. Register new customer:

const { register } = useCustomer();

try {
  await register(
    email,
    password,
    firstName,
    lastName
  );
  // Registration automatically logs in the customer
} catch (error) {
  // Handle registration error
}

3. Logout:

const { logout } = useCustomer();

await logout();
// This will:
// - Clear the stored JWT token
// - Reset customer data
// - Reset cart

Managing Customer Data

1. Access customer information:

import { useLoggedIn } from '@data/hooks';

function MyComponent() {
  const { customer } = useCustomer();
  const isLoggedIn = useLoggedIn();

  // Access customer details
  const {
    email,
    first_name,
    last_name,
    phone,
    billing_address,
    shipping_addresses
  } = customer || {};
}

2. Update customer details:

const { updateCustomer } = useCustomer();

// Update customer information
await updateCustomer({
  first_name: "John",
  last_name: "Doe",
  phone: "+1234567890"
});

3. Refresh customer data:

const { refreshCustomer } = useCustomer();

// Fetch latest customer data from server
await refreshCustomer();

Session Management

The customer session is automatically managed:

• JWT token is stored in AsyncStorage under ‘auth_token’
• Session is restored on app launch
• Token is automatically attached to API requests
• Session is cleared on logout

🎨 Theme Management

The app includes a flexible theming system with built-in light/dark mode support and multiple color schemes.

Basic Usage

import { useColors, useTheme, useThemeName, useColorScheme } from '@styles/hooks';

function MyComponent() {
  const colors = useColors();          // Get current theme colors
  const themeName = useThemeName();    // Get current theme name
  const { colorScheme } = useColorScheme(); // Get 'light' or 'dark'

  // Access theme colors
  const {
    primary,            // Brand/accent color
    background,         // Main background
    backgroundSecondary,// Secondary/card background
    content,           // Main text color
    contentSecondary   // Secondary text color
  } = colors;
}

Setting Default Theme

// In app.tsx, set your preferred theme name in ThemeProvider
<ThemeProvider name="default">
  {/* ... other providers */}
</ThemeProvider>

Available theme names:

• “default” (Purple accent)
• “vintage” (Warm red accent)
• “funky” (Teal accent)
• “eco” (Green accent)

Changing Themes

import { useTheme } from '@styles/hooks';

function ThemeSwitcher() {
  const { setThemeName } = useTheme();
  
  // Switch to a different theme
  const switchTheme = (name: string) => {
    setThemeName(name); // 'default' | 'vintage' | 'funky' | 'eco'
  };
}

System Dark Mode

The theme system automatically responds to system dark mode changes through NativeWind’s useColorScheme hook. Each theme includes both light and dark variants that are automatically applied based on the system setting.

Styling Components

The app uses NativeWind (TailwindCSS) for styling. Theme colors are available as Tailwind classes:

function ThemedButton() {
  return (
    <TouchableOpacity className="bg-primary"> // Theme primary color
      <Text className="text-content font-bold"> // Theme content color
        Click Me
      </Text>
    </TouchableOpacity>
  );
}

🪝 Useful Hooks

The app provides additional hooks for common functionality:

import { 
  useProductQuantity,
  useVariantQuantity,
  useCartQuantity,
  useCurrentCheckoutStep,
  useActivePaymentSession,
  useLoggedIn,
  useCountries
} from '@data/hooks';

// Get quantity of a specific product in cart
const quantity = useProductQuantity(productId);

// Get quantity of a specific variant in cart
const variantQuantity = useVariantQuantity(variantId);

// Get total number of items in cart
const cartQuantity = useCartQuantity();

// Get current checkout step
const checkoutStep = useCurrentCheckoutStep(); 
// Returns: 'address' | 'delivery' | 'payment' | 'review'

// Get active payment session in checkout
const paymentSession = useActivePaymentSession();

// Check if user is logged in
const isLoggedIn = useLoggedIn();

// Get formatted list of countries for current region
const countries = useCountries();
// Returns: Array<{ label: string, value: string }>

Read the detailed documentation in the official repo of Medusa Mobile

Next Steps

Your Medusa mobile app is now running! Here’s what to do next:

Customize Your App

• Select one theme from the built-in themes, customize one of them, or build a new theme config to match your app requirement.
• Modify UI as needed. You have access to full source code andthe ability to change anything.
• Add custom features using Medusa’s API

Production Release

Follow React Native’s Release Guide for Android and iOS

Publishing to Google Play Store

Publishing to iOS App Store

Wrapping up

Start building your mobile commerce experience with React Native and Medusa today! Check out the GitHub repository of Medusa Mobile for the complete source code.

The post Ultimate Guide: Build A Mobile E-commerce App With React Native And Medusa.js appeared first on Coding is Love.

This error happens if you have recently added any properties to a widget and try to render the widget with a hot reload.

It is probably because Flutter’s Hot Reload did not refresh the code properly. Just do a full restart by pressing Ctrl + Shift + F5 or by clicking on the restart button in VScode. The issue should be gone now!

The post Flutter lookup failed in @fields error (solved) appeared first on Coding is Love.

Here’s a free alternative to Notion along with AI

Introducing Novel

Novel is a Notion-style WYSIWYG editor with AI-powered autocompletion.

Here’s a demo video attached below

Deploy Your Own

You can deploy your own version of Novel to Vercel with one click:

Deploy to Vercel

Setting Up Locally

To set up Novel locally, you’ll need to clone the repository and set up the following environment variables:

• OPENAI_API_KEY – your OpenAI API key (you can get one here)
• BLOB_READ_WRITE_TOKEN – your Vercel Blob read/write token (currently still in beta)

If you’ve deployed this to Vercel, you can also use vc env pull to pull the environment variables from your Vercel project.

Tech Stack

Novel is built on the following stack:

• Next.js – framework
• Tiptap – text editor
• OpenAI – AI completions
• Vercel AI SDK – AI library
• Vercel – deployments
• TailwindCSS – styles
• Cal Sans – font

Conclusion

Credits to @steventey for developing this amazing project!

The post Free open source alternative to Notion along with AI appeared first on Coding is Love.

Threads API

There is no official developer API for Threads yet but a developer reverse-engineered the Threads API requests and created an unofficial API client.

The API client is an unofficial, Reverse-Engineered Node.js/TypeScript client for Meta’s Threads.

📦 Installation

yarn add threads-api
# or with npm
npm install threads-api
# or with pnpm
pnpm install threads-api

// or in Deno 🦖
import ThreadsAPI from 'npm:threads-api';

const threadsAPI = new ThreadsAPI.ThreadsAPI({});

Threads API Usage

It is as simple as importing the API client and using the client’s methods. If you want to access public data then you can directly use the API but if you want to access private methods such as publishing a thread or following someone then you should initialize the API with username and password

Checkout the examples below:

How to fetch threads user profile from API

import APIClient from "threads-api";

const main = async () => {
  const threadsAPI = new APIClient.ThreadsAPI();

  const username = "codingislove";

  // 👤 Details for a specific user
  const userID = await threadsAPI.getUserIDfromUsername(username);
  if (!userID) {
    return;
  }
  const user = await threadsAPI.getUserProfile(username, userID);
  console.log(JSON.stringify(user));
};

main();

Response:

{
  "is_private": false,
  "profile_pic_url": "https://scontent.cdninstagram.com/v/t51.2885-19/358193075_291108399947602_86677529474390528_n.jpg?stp=dst-jpg_s150x150&_nc_ht=scontent.cdninstagram.com&_nc_cat=110&_nc_ohc=qa3mujfMuOMAX_hdows&edm=APs17CUBAAAA&ccb=7-5&oh=00_AfBjrANoN_vgzct9EOFSe3NZACDpJijVQbwXnUsgUIkDuQ&oe=64B34485&_nc_sid=10d13b",
  "username": "codingislove",
  "hd_profile_pic_versions": null,
  "is_verified": false,
  "biography": "If you're a developer, you should follow this account 🤖",
  "biography_with_entities": null,
  "follower_count": 4,
  "profile_context_facepile_users": null,
  "bio_links": [{ "url": "https://codingislove.com/" }],
  "pk": "5635301639",
  "full_name": "Coding is Love",
  "id": null
}

✨ How to publish a thread using API

import APIClient from "threads-api";

const publishThread = async () => {
  const threadsAPI = new APIClient.ThreadsAPI({
    username: '_junhoyeo', // Your username
    password: 'PASSWORD', // Your password
  });

  await threadsAPI.publish({
    text: '🤖 Hello World',
  });
};

publishThread();

✨ Threads with Image

await threadsAPI.publish({
  text: '🤖 Threads with Image',
  image: 'https://github.com/junhoyeo/threads-api/raw/main/.github/cover.jpg',
});

✨ Threads with Link Attachment

await threadsAPI.publish({
  text: '🤖 Threads with Link Attachment',
  url: 'https://github.com/junhoyeo/threads-api',
});

✨ Reply to Other Threads

const parentURL = 'https://www.threads.net/t/CugF-EjhQ3r';
const parentPostID = await threadsAPI.getPostIDfromURL(parentURL); // or use `getPostIDfromThreadID`

await threadsAPI.publish({
  text: '🤖 Beep',
  link: 'https://github.com/junhoyeo/threads-api',
  parentPostID: parentPostID,
});

✨ Like/Unlike a Thread

const threadURL = 'https://www.threads.net/t/CugK35fh6u2';
const postIDToLike = await threadsAPI.getPostIDfromURL(threadURL); // or use `getPostIDfromThreadID`

// 💡 Uses current credentials
await threadsAPI.like(postIDToLike);
await threadsAPI.unlike(postIDToLike);

✨ Follow/Unfollow a User

const userIDToFollow = await threadsAPI.getUserIDfromUsername('junhoyeo');

// 💡 Uses current credentials
await threadsAPI.follow(userIDToFollow);
await threadsAPI.unfollow(userIDToFollow);

❤️‍🔥 Delete a Post

const postID = await threadsAPI.publish({
  text: '🤖 This message will self-destruct in 5 seconds.',
});

await new Promise((resolve) => setTimeout(resolve, 5_000));
await threadsAPI.delete(postID);

Supported features

• ✅ Read public data
  •  ✅ Fetch UserID(314216) via username(zuck)
  •  ✅ Read User Profile Info
  •  ✅ Read the list of User Threads
  •  ✅ Read the list of User Replies
  •  ✅ Fetch PostID(3140957200974444958) via PostID(CuW6-7KyXme) or PostURL(https://www.threads.net/t/CuW6-7KyXme)
  •  ✅ Read Threads via PostID
  •  ✅ Read Likers in Thread via PostID
  •  🚧 Read User Followers
  •  🚧 Read User Followings
•  🚧 Read private data
• ✅ Write data (i.e. write automated Threads)
  • ✅ Create a new Thread with text
    •  ✅ Make link previews to get shown
  •  ✅ Create a new Thread with a single image
  •  🚧 Create a new Thread with multiple images
  •  ✅ Reply to existing Thread
  •  ✅ Delete Thread
• ✅ Friendships
  •  ✅ Follow User
  •  ✅ Unfollow User
• ✅ Interactions
  •  ✅ Like Thread
  •  ✅ Unlike Thread

Conclusion

Checkout the official repo for more options and updates

Also, read How to Send SMS from API or Backend 📲

The post Threads API for developers for programmatic access appeared first on Coding is Love.

Deep Face Live Free

Deep Face Live is a free open-source software that you can use to swap faces in a video or swap faces in a real-time stream like video calls, webcam recording, etc.

Let’s see how to swap faces in a video for free using this software

Pre-requisites

You’ll need a PC with a decent graphic card and RAM for this software to work.

Installation

Step 1: Download

Download DeepFaceLive from here

Download the latest NVIDIA build if you have a NVIDIA graphic card or else download the DirectX12 build.

Step 2: Set total virtual memory to 32 GB or more.

Press Windows + R on your keyboard and type sysdm.cpl

Click on the advanced tab on the top and click on settings under the performance tab

Select the Advanced tab again and click on “Change” in the virtual memory section

Select C drive > Select custom size > Enter 16384 in Initial size > Enter 32768 in Maximum size

Click Ok > Apply and restart your PC to apply the changes to virtual memory.

Step 3: Extract and open

Double-click on the download build file. It’ll open an extractor. Select the root of any one of the drives. I’ve selected E: in my case.

Open the extracted folder and double-click on the DeepFaceLive.bat file

Step 4: Replace the video

Select a Video file in the file source

Choose a Face detector and Device

Choose a Face marker and Device

Choose the Model and Device in Face Swapper

Now you see a swapped face in the Final frame preview window

in Stream output choose Mode: Merged frame, Press the play button, and press window

Now you can see the live output in the deep face live output window

A Working demo of the video with the face replaced

Check out the final output video where multiple characters’ face in the video is replaced with Elon Musk. Please don’t sue me

How to save the output video?

Select a folder in the stream output section. Make sure that you select an empty folder as multiple images will be saved to that folder.

Now, Click on the play button and wait till the video playback completes. The video frames (images) with the face replaced will be generated in the selected folder.

How to convert generated image sequence to a video?

I personally use Adobe premiere pro to import the image sequence in the form of a video and then export it. Here’s how to do it premiere pro: Click on import in premiere pro > Select the first image and make sure to tick the Image Sequence checkbox.

After this, The image sequence will be imported in the form of a video that you can export it as an MP4 or any video format that you want.

You can also use any online tools to convert an image sequence into a video. I did not find a good tool so I used Adobe Premiere Pro

Mac/Linux support

I have tried it out only on Windows but you can try it out on Mac/Linux as mentioned in the docs

Requirements

• Nvidia-driver-470 (current)
• cuda 11.4 (current)

Setup

git clone DeepFaceLive
cd DeepFaceLive/build/linux/
# start.sh builds and runs container with proper options, then example.sh will start DeepFaceLive with example options
./start.sh

Usage of ./start.sh
# -d specify a folder for DeepFaceLive data (videos, models, etc)
-d /home/user/DeepFaceLive_data
# -c will pass through existing video devices such as /dev/video0 and /dev/video1, etc

Supported face models

The library has already trained multiple face models which you can readily use. Check out all the trained models here

If you want a higher quality or better face match, you can train your own face model using DeepFaceLab

Use your own picture to replace

If you want to use your own pictures instead of the existing face models then you can do it as well.

Simply take a pic of your face in a passport-size format > Click on the Eye icon in the Face Swap (Insight section) > Paste your image there > Click on the refresh icon next to the eye icon in the Face Swap section.

Now you’ll be able to see your picture name in the Face dropdown. Select your picture name and click on the play button to run the analysis and replace the face in the video with your face!

Conclusion

You can also use this library to replace face in live streams as well. Go ahead and try it out by changing the file source!

The clarity of the face swap is surprisingly good even without tweaking any configuration parameters. If you want to further fine-tune it then you can do it by playing around with different face detector models and face aligner configuration options

The post How to replace face in a video for free? appeared first on Coding is Love.

Missing a MIME Type? Comment below, We’ll update it.

The post The Complete list of all MIME Types updated – 2023 appeared first on Coding is Love.

This is a fun effect created to showcase the power of Javascript animations.

Live demo and Full source code

See the Pen AI Slider by Chris Gannon (@chrisgannon) on CodePen.

The post Amazing AI slider created using javascript animations appeared first on Coding is Love.

DiceBear

DiceBear is an avatar library for designers and developers. Create avatars for your profiles, designs, websites, or apps. Piece by piece or based on a seed.

Features

• More than 25 avatar styles!
• Fully customizable!
• Free and fast HTTP API!

Examples

How to use it?

Are you a designer and need avatars for your design? Then check out their Figma Plugin and Editor. As a developer, you could take a look at the HTTP API, the CLI, the JS library or the Playground. Which is more appropriate for you, depends on the programming language and environment you are using.

In a JavaScript environment, you could use the JS library or the HTTP API if the JS library is too large for you. In other environments, you might be interested in the HTTP API or the CLI if you are concerned about the stability or latency of the HTTP API.

The CLI is always a good choice for automation or if you want to create a large number of avatars in different image formats.

How does it work?

The avatars are created in SVG format. This allows to generate avatars dynamically without much computing power. In most cases, various SVG elements such as hair, eyes, ears, etc. are selected from a set and combined to create a character/avatar.

XorShift32 is used as the algorithm for the PRNG. It is important to note that the PNGR does not attempt to be cryptographically secure.

Usage

HTTP API:

https://api.dicebear.com/6.x/adventurer/svg

<img
  src="https://api.dicebear.com/6.x/adventurer/svg"
  alt="avatar"
/>

JS-Library:

First install the required packages via npm:

npm install @dicebear/core @dicebear/collection --save

Then you can create this avatar as follows:

import { createAvatar } from '@dicebear/core';
import { adventurer } from '@dicebear/collection';

const avatar = createAvatar(adventurer, {
  // ... options
});

const svg = avatar.toString();

CLI:

First install the CLI package via npm:

npm install --global dicebear

Then you can create this avatar as follows:

dicebear adventurer

Get a specific avatar

If you want to get a specific avatar using a name then you can use the seed option

Example:

https://api.dicebear.com/6.x/avataaars/svg?seed=Buster

Output:

Conclusion

This is a very useful library for generating avatars for your next project. Head over to their playground for exploring further

The post Free avatar library for developers and designers | DiceBear appeared first on Coding is Love.

Introducing Invoice CLI

Generate invoices from the command line using this CLI tool

Installation

Install with Go:

go install github.com/maaslalani/invoice@main

Or download a binary from the releases.

Command Line Interface

invoice generate --from "Company A, Inc." --to "Company B, Inc." \ --item "Laptop" --quantity 2 --rate 500 \ --tax 0.1 --discount 0.15 \ --note "Paid via online transfer"

The PDF would be generated in the same folder in which you are running the command. You can customize the output location with --output.

Sample output

Here’s an example of the generated PDF after running the above command

Environment

Save repeated information with environment variables:

export INVOICE_LOGO=/path/to/image.png
export INVOICE_FROM="Dream, Inc."
export INVOICE_TO="Imagine, Inc."
export INVOICE_TAX=0.13
export INVOICE_RATE=25

Generate new invoice:

invoice generate \
    --item "Yellow Rubber Duck" --quantity 5 \
    --item "Special Edition Plaid Rubber Duck" --quantity 1 \
    --note "For debugging purposes." \
    --output duck-invoice.pdf

Configuration File

Or, save repeated information with JSON / YAML:

{
    "logo": "/path/to/image.png",
    "from": "Dream, Inc.",
    "to": "Imagine, Inc.",
    "tax": 0.13,
    "items": ["Yellow Rubber Duck", "Special Edition Plaid Rubber Duck"],
    "quantities": [5, 1],
    "rates": [25, 25],
}

Generate a new invoice by importing the configuration file:

invoice generate --import path/to/data.json \
    --output duck-invoice.pdf

Custom Templates

Unfortunately, The CLI doesn’t allow custom invoice templates. If you would like a custom invoice template for your business or company, please reach out to the author via:

• Email
• Twitter

Also, Read Machine Learning for beginners, a Free curriculum from Microsoft

The post How to generate an invoice from the command line? appeared first on Coding is Love.