Bergsonne Labs
Bergsonne Labs

Revolutionizing
Embedded Intelligence

Standardised microelectronic tiles for sensing, processing, actuation, power management, memory, and communications — one platform from the benchtop to mass production.

Tiles on a carrier board

Standardized Intelligent Modules

As semiconductor components continue to increase in performance and complexity while simultaneously decreasing in size, the layout, fabrication, assembly, and packaging of embedded electronics is becoming ever more challenging. Tiles directly address this mismatch by compartmentalizing the complexity of modern electrical subsystems into fully-integrated, standardized, plug-and-play microelectronic modules.


Tiles close-up

From Concept to Mass Production

By modularizing at the subsystem level, Tiles seamlessly carry a design from initial concept all the way through mass production using the same hardware. Instead of getting mired in complex design bottlenecks, exorbitant production costs, and tedious rounds of advanced PCB fabrication and assembly, designers and engineers can focus their time, resources, and energy on the things that really matter: product functionality and user experiences.


Tile Catalog

With over 75 tiles spanning eight distinct categories, the platform covers the full range of embedded subsystems. All tiles communicate over standard commercial interfaces (I2C, SPI, USB) and are supported by an open-source C/C++ firmware library with starter code and reference projects, making integration straightforward whether you’re building a one-off research prototype or scaling to volume production.


Fundamentals & Resources

Standard Dimensions

Most tiles conform to a standard 4.0 × 4.0 mm T44 package with ten surface-mount pads arranged along the left and right edges with a pitch of 0.8 mm. Encapsulated in epoxy, the tile has an overall package height between 1.0 and 2.0 mm. The orientation of the tile can be determined from above via the marking dot or below via the extended length of the first pad.

T44 package drawing — 4.0 × 4.0 mm, 10 pads, 0.8 mm pitch

Common Pads

All T44 tiles share a common pad arrangement for the power supply, with GND on pad 1 and the supply voltage on pad 10. In addition, the majority of tiles are configured for standard I3C communications with the clock line on pads 4 and the data line on pad 5. The remaining six pads are tile-specific and carry additional interfaces such as SPI (typically on pads 2-5), analog signals, interrupts, and/or GPIO.

T44 common pad assignment

Rapid Prototyping Tools

Available in early Spring, 2026, the new solderless tile-to-breadboard adapter enables true plug-and-play functionality, allow for extremely fast prototyping of new tile concepts and integration strategies. With the pads arranged left to right across the adapter, the connection of multiple tiles into larger systems is fast and intuitive.

Prototiler breadboard adapter

Simplified Assembly & Reusability

Moving beyond solderless prototyping, Tiles can be assembled into larger systems using either traditional soldering techniques or conductive adhesives. With 0.4mm traces and all of the complexity embedded into the tile, the simple (often single-sided) carrier boards can be automatically generated and then printed, laser etched, or fabricated using inexpensive equipment. In addition, the inherent modularization of Tiles allows for effortless reuse by simply reversing the assembly process.

Tile assembly on carrier board

Platform-Agnostic Drivers

Open-source platform-agnostic drivers handle low-level register configuration, data parsing, and protocol negotiation, while a thin Platform Abstraction Layer (PAL) bridges between the tiles and higher-level processor(s). Ready-made PAL implementations are available for Core tiles with STM32 processors, while ports for ESP32, Arduino, and nRF are coming soon.

// tile_i2c.h
#ifndef TILE_I2C_H
#define TILE_I2C_H
#include "tile.h"
#include <stdint.h>
#include <stddef.h>
/** I2C bus configuration */
typedef struct tile_i2c_cfg {
uint8_t addr;
uint32_t speed_hz;
uint8_t pullup_en;
uint8_t timeout_ms;
} tile_i2c_cfg_t;
/** Initialize I2C peripheral */
int tile_i2c_init(const tile_i2c_cfg_t *cfg);
int tile_i2c_deinit(void);
/** Read/write operations */
int tile_i2c_read(uint8_t reg, uint8_t *buf, size_t len);
int tile_i2c_write(uint8_t reg, uint8_t val);
int tile_i2c_burst_write(uint8_t reg, const uint8_t *data, size_t len);
int tile_i2c_probe(uint8_t addr);
/** Register helpers */
int tile_i2c_set_bits(uint8_t reg, uint8_t mask);
int tile_i2c_clr_bits(uint8_t reg, uint8_t mask);
int tile_i2c_modify(uint8_t reg, uint8_t mask, uint8_t val);
#endif // TILE_I2C_H

Programs & Community

Tile kits and collections

Kits & Collections

Pre-configured kits bring together curated sets of tiles, carrier boards, and accessories for specific use cases. Whether you’re teaching an embedded-systems course, bootstrapping a hardware startup, or outfitting a research lab, each kit provides everything needed to get up and running quickly — no sourcing, no guesswork.


Tiles in education

Tiles in Education

Tiles are a natural fit for the classroom. By packaging complex subsystems into standardized, reusable modules, they let students engage with real embedded hardware from the first lab session — without weeks of PCB layout and assembly. Our education program offers course-specific kits, reduced academic pricing, subscription options for recurring lab sections, and dedicated support for student projects. Initially focused on university-level embedded-systems and mechatronics courses, the program will expand to youth education as the platform and catalog mature.


Pilot program — tile testing

Pilot Program

Get hands-on with tiles before they hit the catalog. The Pilot Program gives researchers, hobbyists, and hackers early access to unreleased tiles in exchange for community contributions — firmware drivers, example projects, bug reports, or documentation. Help shape the platform while building something new.


Project inspiration — AudioTouch tiles

Project Inspiration

See what others are building with tiles. From compact sensor nodes and wearable prototypes to autonomous robots and environmental monitors, this gallery showcases real projects from the community. Have something to share? Submit your build and inspire the next wave of embedded creators.