Vimag Labs’ Magnetless Motor Breakthrough: India’s Software-Defined Challenge to Rare-Earth Dependence...

 In the electric vehicle (EV) world, rare-earth permanent magnets have long been the hidden bottleneck. They deliver the high efficiency and torque that power most modern EVs, but they come with massive supply-chain risks—China dominates ~90% of rare-earth processing and a huge share of the high-performance NdFeB magnets used in motors.

A Bengaluru-based deep-tech startup called Vimag Labs (sometimes associated with the Volektra brand) claims to have cracked a compelling alternative: a Virtual Magnet Synchronous Motor (VMSM) that eliminates rare-earth magnets entirely by using software, power electronics, and clever electromagnetic design.

What Is a Magnetless (or “Virtual Magnet”) Motor?

Traditional Permanent Magnet Synchronous Motors (PMSMs) embed strong rare-earth magnets in the rotor. These create a fixed magnetic field that interacts with the stator’s rotating field to produce torque. It’s efficient, compact, and powerful—but dependent on critical minerals.

Vimag’s VMSM removes those physical magnets. Instead:

• It uses a brushless, slip-ring-free architecture.
• A rotating transformer (patented) wirelessly transfers power to the rotor.
• Proprietary control algorithms and power electronics dynamically generate and control the rotor’s magnetic field in real time—essentially creating a “virtual magnet” whose strength and behavior can be tuned on the fly.

The result, according to the company, is a synchronous motor that matches or exceeds the performance of traditional PMSM designs in efficiency, torque, and power density—while using only common materials like copper and steel.

The Latest Milestone: Fifth Indian Patent

In July 2026, Vimag Labs was granted its fifth Indian patent, titled “A Robust Rotating Transformer Excited Synchronous Motor and Its Control.” This protects the core architecture of the VMSM platform.

The company now has:

• 5 granted patents
• 10 additional patent applications
• 15 trademarks

This IP covers motor design, software controls, power electronics, and application-specific tweaks. CEO and co-founder Manish Seth (with prior experience at Volkswagen, Ford, and GM) noted the patent represents over 87,600 engineering hours.

Why This Matters — Strategic and Commercial Angles

Supply Chain Independence
By going magnet-free, Vimag reduces exposure to geopolitical risks and price volatility in rare-earth materials. This is especially relevant for India and any nation seeking to localize EV manufacturing.

Cost and Flexibility
No rare-earth magnets can lower bill-of-materials costs. The software-defined nature also opens the door to performance improvements via firmware updates rather than hardware redesigns.

Target Applications

• Two-wheelers and passenger vehicles (current pilots)
• Light & heavy commercial vehicles
• Industrial systems (200–600 kW)
• Robotics, defense, and cooling systems

Vimag recently raised $5 million in Series A funding led by Accel, with participation from Chakra Growth Fund and Thinkuvate. They’ve also signed a manufacturing MoU with Jendamark to support scale-up.

Challenges and Realistic Outlook

This is still early-stage technology. While the claims are impressive—matching or beating PMSM performance without magnets—the technology has not yet been independently verified at full production scale. Many magnetless or reduced-rare-earth approaches (induction motors, switched reluctance motors, etc.) have historically traded off efficiency, torque density, or added complexity like brushes/slip rings.

Vimag’s brushless rotating-transformer approach aims to avoid those classic downsides. Success will depend on real-world validation in pilots, thermal management, long-term reliability, and cost at volume.

The Bigger Picture

Vimag Labs, founded in September 2025, is part of a growing wave of innovation seeking to make EVs less dependent on a handful of critical materials. If the VMSM platform delivers on its promises, it could accelerate India’s (and the world’s) ability to build high-performance electric motors domestically—using software smarts instead of imported magnets.

The road from promising patent to mass-market adoption is long, but the direction is exciting: turning the motor itself into a software-defined component.

Watch VIMAG...

I am sure it will be worthy your time...

Jai Hind...

The Fragility of Time: NavIC Clocks, White Rabbit, and Bharat’s Path to True Digital Sovereignty...

The word Vishwaguru (a global leader) implies self-sufficiency—the ability to stand tall on homegrown foundations without critical single points of failure. Yet, when we examine the backbone of modern digital civilizations—Timing and Navigation—a sobering technical truth emerges.

Without microsecond-level synchronization, modern power grids fail, 5G networks drop calls, stock markets lose trade order, and guided systems drift off-target.

The recent setbacks faced by India's NavIC (Navigation with Indian Constellation) due to atomic clock failures, contrasted with our rollout of ground-based White Rabbit technology, offer a masterclass in why Bharat must secure its hardware stack from the silicon layer up.

1. The NavIC Dilemma: Space-Segment Timing Fragility

Satellite navigation systems (GNSS) don't actually measure distance; they measure time. A receiver calculates its position on Earth by measuring the fraction-of-a-nanosecond delay of signals traveling at the speed of light from multiple orbiting satellites via trilateration.

If a satellite's onboard clock drifts by even 1 microsecond, your ground position calculation errs by 300 meters.

[Satellite 1]     [Satellite 2]     [Satellite 3]     [Satellite 4]
    \                 |                 |                 /
     \                |                 |                /
      +---------------+-----------------+---------------+
                              |
                     [Ground Receiver]
             Requires ≥ 4 valid clocks for (X, Y, Z, t)

To achieve precise Position, Navigation, and Timing (PNT), a constellation needs a minimum of 4 operational satellites with healthy atomic clocks.

Where the Bottleneck Occurred

• The Dependency Trap: Early IRNSS satellites relied on imported RAFS (Rubidium Atomic Frequency Standard) clocks. When these imported units began failing prematurely in orbit, entire satellites were rendered functionally useless for PNT, despite having healthy propulsion and solar arrays.
• The Replenishment Race: While ISRO successfully developed indigenous rubidium clocks for the second-generation NVS-01 satellite, hardware supply chain delays and launch anomalies (such as NVS-02 failing to reach its intended orbit) mean replenishment couldn't keep pace with the degradation of aging space hardware.

The lesson is stark: You cannot claim strategic autonomy in space if your core timing mechanism rests on foreign components.

2. White Rabbit: The Terrestrial Ground Truth

While space-based timing faces orbital hurdles, India has taken a major step forward on the ground with White Rabbit (WR) technology under the One Nation, One Time initiative.

Originally engineered at CERN, White Rabbit is an open-source extension of Ethernet (IEEE 802.3) and the Precision Time Protocol (PTP / IEEE 1588). It synchronizes clocks over fiber-optic networks with sub-nanosecond precision.

                       [CSIR-NPL / UTC(NPLI)]
                         (Primary Time Standard)
                                   |
                         [WR Grandmaster Switch]
                                   |
             +---------------------+---------------------+
             | (Fiber Optic)                             | (Fiber Optic)
             v                                           v
   [NSE / BSE Trading Engine]                   [5G Core & Cell Towers]
   Timestamping: < 1 nanosecond                 Phase Sync: < 1.5 microseconds

How White Rabbit Works

WR achieves sub-nanosecond synchronization by combining two core techniques:

1. Synchronous Ethernet (SyncE): The receiving node locks its physical layer clock frequency directly to the transmitter's bitstream, eliminating clock frequency drift.
2. DDMTD Phase Detection: Dual-Mixer Time-Difference circuits measure the phase offset between transmitted and reflected signals down to picoseconds, continuously adjusting for temperature-induced fiber latency variations.

Deploying WR nodes across national stock exchanges (like the NSE), power grids, and telecom networks decouples critical ground infrastructure from external space-based GNSS signals (like US GPS), protecting them against satellite failures, jamming, or spoofing.

3. The Grand Gap: Why Ground Timing Isn't Enough

While White Rabbit secures stationary ground nodes, it cannot guidance-control an airborne vehicle, assist a naval vessel in open ocean, or serve mobile smartphones. Ground-based fiber networks and space-based constellations are two halves of the same sovereign coin.

True digital sovereignty requires mastering the entire spectrum:

Layer	Technology	Current Status	Sovereign Goal
Terrestrial Network	White Rabbit / SyncE	Active rollout across NPL & exchanges	Nationwide WR fiber ring for UPI, 5G, & Grids
Space-Segment Clocks	Rubidium / Cesium Standards	Transitioning from imported to ISRO RAFS	100% space-qualified indigenous atomic clocks
Silicon & Fab	Navigation Baseband ICs	Mixed; reliance on foreign foundries	Domestic fab production of radiation-hardened ICs
User Ecosystem	Smartphone Baseband Chips	Growing L5/L1 NavIC adoption	Mandated dual-frequency NavIC in all domestic hardware

4. Before Vishwaguru: The Blueprint for Real Digital Autonomy

For Bharat to be a true technological leader, we must bridge the gap between intent and execution across critical infrastructure:

1. Foundational Component Independence: Developing indigenous atomic clocks is a huge step forward, but we must also control the underlying semiconductor fabrication. A home-designed clock printed on foreign silicon remains vulnerable to geopolitical chokepoints.
2. Constellation Redundancy & Fast-Track Logistics: Replenishment pipelines for space assets must be agile. When a satellite clock degrades, replacement payloads must be ready for rapid launch rather than waiting through multi-year assembly backlogs.
3. Hardware-Level Integration: White Rabbit must be mandated across all critical national infrastructure—from regional load dispatch centers to banking cores—creating an unshakeable ground truth for Indian Standard Time (IST).

Final Thoughts

The failure of an orbiting clock or a launch insertion is not a cause for cynicism; it is a hard-engineering reality check. True sovereignty is built by facing these failure modes head-on.

By combining the terrestrial precision of White Rabbit with a resilient, 100% indigenized NavIC space segment, Bharat can build a timing and navigation architecture that is truly unshakeable—from the fiber in our ground to the orbits overhead.

Bridge Pattern using Python...

Bridge Pattern is a structural design pattern that decouples an abstraction from its implementation, allowing both to evolve independently.

Why it exists (The Problem)When you have classes that can vary in two or more independent dimensions, simple inheritance leads to a combinatorial explosion of subclasses.
Example:

• You have shapes: Circle, Square
• You have rendering APIs: OpenGL, DirectX, Vulkan

Using inheritance, you end up with: CircleOpenGL, CircleDirectX, SquareOpenGL, etc. — and it gets worse as you add more shapes or renderers.Solution: Bridge PatternThe pattern splits the class into two hierarchies:

1. Abstraction – High-level control logic (e.g., Shape)
2. Implementation – Low-level platform-specific details (e.g., Renderer)

These two hierarchies are connected via a bridge (composition instead of inheritance).
Here is a Python implementation of the Bridge Pattern.

from abc import ABC, abstractmethod

# ==================== Implementor 1: Color ====================
class Color(ABC):
    @abstractmethod
    def get_color(self) -> str:
        pass

    @abstractmethod
    def paint(self):
        pass


class Red(Color):
    def get_color(self) -> str:
        return "Red"

    def paint(self):
        print("Painting the vehicle in vibrant Red...")


class Black(Color):
    def get_color(self) -> str:
        return "Black"

    def paint(self):
        print("Painting the vehicle in deep Black...")


# ==================== Implementor 2: Gear ====================
class Gear(ABC):
    @abstractmethod
    def get_type(self) -> str:
        pass

    @abstractmethod
    def shift(self):
        pass


class ManualGear(Gear):
    def get_type(self) -> str:
        return "Manual"

    def shift(self):
        print("Shifting gears manually...")


class AutoGear(Gear):
    def get_type(self) -> str:
        return "Automatic"

    def shift(self):
        print("Shifting gears automatically...")


# ==================== Abstraction: Vehicle ====================
class Vehicle(ABC):
    def __init__(self, color: Color, gear: Gear):
        self.color = color      # Bridge to Color implementor
        self.gear = gear        # Bridge to Gear implementor

    @abstractmethod
    def display(self):
        pass

    def paint_vehicle(self):
        self.color.paint()

    def change_gear(self):
        self.gear.shift()


# ==================== Refined Abstractions ====================
class SmallCar(Vehicle):
    def display(self):
        print(f"=== Small Car ===")
        print(f"Color: {self.color.get_color()}")
        print(f"Gear: {self.gear.get_type()}")
        self.paint_vehicle()
        self.change_gear()
        print("Driving smoothly in the city...\n")


class Truck(Vehicle):
    def display(self):
        print(f"=== Truck ===")
        print(f"Color: {self.color.get_color()}")
        print(f"Gear: {self.gear.get_type()}")
        self.paint_vehicle()
        self.change_gear()
        print("Hauling heavy load on the highway...\n")


# ==================== Client Code ====================
if __name__ == "__main__":
    # Create implementors
    red = Red()
    black = Black()
    auto = AutoGear()
    manual = ManualGear()

    # Create vehicles with different combinations (independent variation)
    print("Creating vehicles using Bridge Pattern:\n")

    car1 = SmallCar(red, auto)
    car1.display()

    car2 = Truck(black, manual)
    car2.display()

    car3 = SmallCar(black, auto)
    car3.display()

Here's what the above solution would look like without the Bridge Pattern - look at the image below.

Look at the left-side hierarchy of classes. With more and more attributes, the inheritance tree would have exploded.

So... comes the Bridge Pattern - a nice solution without so many classes as depicted in the right hierarchy of classes.

I hope I have clarified the Bridge Pattern clearly.

Enjoy...