Galileo Glass UI — Version 1.0.27

Craft Interfaces That Feel Alive.

Experience interactions so fluid and natural, they feel instantly familiar. Galileo integrates advanced physics directly into your UI, enabling components that respond with lifelike precision.

Build truly dynamic and engaging applications. Explore a rich ecosystem of components designed for interaction, and unlock ultimate creative freedom with direct access to the core physics simulation.

Physics Animation System

Intuitive Spring Dynamics • Collision Detection
collision detection
DataChart (Modular)
GlassTimeline
GlassDataGrid
GlassStepper
+86 more components

Galileo Glass UI Features

90+ Components Powered By Physics

The Complete Glass UI System

Our revolutionary Physics Animation System brings interfaces to life with spring dynamics, magnetic interactions, constraints, layouts, and precise motion control—all engineered for exceptional performance and seamless accessibility.

Physics-Powered Animation

Experience UI that feels alive with naturally responsive spring dynamics, magnetic interactions, intelligent collision detection, and enhanced event data that responds to every interaction.

79 Glass Components

An expansive suite of specialized Glass components, including the new DataGrid and Stepper, meticulously crafted for stunning visuals and seamless integration.

Sophisticated Glassmorphism

Create breathtaking depth with perfectly calibrated blur, transparency, reflections, and dynamic lighting that adapts to your design language.

Adaptive Performance

Intelligently adjusts to every device with dynamic quality tiers, automatic capability detection, and resource-efficient rendering that ensures fluid 60fps everywhere.

NEW

Accessibility Native

Seamlessly honors user preferences with refined motion sensitivity levels, intelligent alternatives, and the new animated GlassFocusRing for clarity.

Direct Physics Engine Control

Unprecedented control through direct access to our integrated physics engine, enabling sophisticated simulations, physics constraints, and enhanced collision data.

NEW

Physics-Based Layouts

Effortlessly create dynamic layouts (Grid, Stack, Freeform) driven by physics using the dedicated `usePhysicsLayout` hook.

NEW

Ambient Tilt Effect

Subtly respond to user presence by applying a gentle, device-aware tilt effect across elements based on global pointer position.

NEW

Modular Charts with Physics

Build flexible data visualizations with our modular chart system, now enhanced with physics-based zoom and pan interactions.

Animation Orchestration

Choreograph complex multi-step animations with precise timing, dependencies, and staggering for creating memorable interface moments that feel intentional.

NEW

Physics Constraints

Define precise physical relationships between elements using distance, spring, or hinge constraints for complex, realistic interactions.

NEW

Chart Physics Interaction

Enable intuitive, physics-based zoom and pan directly within charts for seamless data exploration using `useChartPhysicsInteraction`.

NEW

GlassDataGrid Component

Display and interact with complex datasets using a performant grid featuring physics-based sorting and drag-and-drop capabilities.

NEW

GlassStepper Component

Guide users through multi-step processes with elegantly animated transitions powered by physics.

NEW

Animated Focus Ring

Enhance accessibility and clarity with the `GlassFocusRing` component and `useGlassFocus` hook, providing clear, animated focus indication.

NEW

Enhanced Collision Data

Gain deeper insights into physical interactions with detailed collision event data, including impact force, point, and velocity.

Glass UI Animation System

Dynamic Motion, Intuitively Crafted

Galileo Physics Animation System

Bring interfaces to life with animations that feel natural and responsive. Use intuitive hooks for common effects, or dive deep with direct access to the powerful physics engine for ultimate control.

Spring Physics Demo

Fluid spring dynamics for intuitive movement.

Click or Drag
Click or drag to apply forces
Presets
Stiffness: 120Spring Stiffness
Damping: 0.6Bounciness
Mass: 1.0Object Weight

Interactive Physics

Apply realistic physics to UI elements with spring dynamics, magnetic attraction, and realistic inertia.

Hooks: usePhysicsInteraction, useMagneticElement

Gesture & Movement

Create natural movement with drag physics, Z-space depth effects, orchestrated multi-step animations, ambient tilt, and physics-based layouts.

Hooks: useGesturePhysics, useZSpaceAnimation, useAnimationSequence, useAmbientTilt, usePhysicsLayout

Direct Engine Access

For advanced users, gain granular control over the entire physics world, including constraints and enhanced collision data, for custom simulations.

Hooks: useGalileoPhysicsEngine, usePhysicsConstraint

Performance & Accessibility

Animation quality adapts to device capabilities and respects user motion preferences.

Hooks: useQualityTier, useDeviceCapabilities, useReducedMotion

Glass UI Theme System

Advanced Theming Architecture

Intelligent Theme System

A sophisticated multi-context architecture designed for maximum flexibility and performance. Adapt your interface to any brand, style, or user preference with elegant transitions.

Select Theme Variant

Choose a theme to see components adapt automatically via the integrated theme context.

Theme System Features (v1.0.22+):

  • Multi-context architecture
  • Physics-enhanced UI elements
  • Theme-aware components (FocusRing)
  • Animated theme transitions

Component Demo nebula Theme

Themed Card

This card adapts to the 'nebula' theme.

Focus Active: No | Ring Variant: primary

GlassStepper

1

Select Item

2

Configure

3

Confirm

GlassDataGrid

ComponentThemed?
CardYes
ButtonYes
StepperYes
DataGridYes
FocusRingYes

Glass UI Chart Components

Physics-Powered Data Visualization

Glass Charts & Data Visualization

Immersive, interactive data visualizations with spring physics animations and glass morphism effects

Dynamic Data Visualizations with Physics

Our DataChart component transforms data into beautiful, interactive visualizations. Leverage its modular architecture, adaptive rendering tiers, and physics-based animations.

  • Spring physics animations with customizable parameters
  • Multiple chart types: line, bar, area, pie and KPI displays
  • Interactive glass tooltips with contextual information
  • Adaptive performance with device capability detection
  • Accessible animations that respect reduced motion preferences
  • Modular architecture for flexible composition
  • Physics-Based Zoom/Pan via interaction.zoomPanEnabled prop

Monthly Revenue

100%
Monthly Revenue

Interactive mode is enabled. Click on data points, try zooming (scroll wheel), and panning (drag).

Customize Chart

Quality: high
Code Example
// Physics-based zoom and pan requires the useChartPhysicsInteraction hook
import { useRef } from 'react';
import { 
  DataChart, 
  useChartPhysicsInteraction 
} from '@veerone/galileo-glass-ui';

function ChartWithPhysicsZoomPan() {
  // Create container ref for the physics interaction
  const chartContainerRef = useRef<HTMLDivElement>(null);
  
  // Initialize physics interaction with stiffness based on your preset
  const physicsInteraction = useChartPhysicsInteraction({
    targetRef: chartContainerRef,
    stiffness: 120, // Adjust based on preset
    dampingRatio: 0.7, // Adjust based on preset
    reducedMotion: false // Use useReducedMotion() hook in real usage
  });
  
  return (
    <div ref={chartContainerRef} style={{ height: '400px' }}>
      <DataChart 
        variant="line"
        datasets={datasets}
        animation={{ physicsEnabled: true, duration: 800 }}
        glassVariant="clear"
        blurStrength="standard"
        // Connect the physics plugin and mode
        chartPlugins={[physicsInteraction.plugin]}
        interaction={{ 
          showTooltips: true,
          zoomPanMode: physicsInteraction.zoomPanMode
        }}
      />
    </div>
  );}

Using Galileo Physics Engine | Quality Tier: high | Reduced Motion: No

Charts adapt automatically to your device capabilities and preferences

Glass UI in Action

Installing Galileo Glass UI

Installation

Get Started in Minutes

Follow these simple steps to integrate Galileo Glass UI into your project.

Step 1: Install Package

1

Install via npm

npm install @veerone/galileo-glass-ui styled-components

(`react`, `react-dom`, `styled-components` are required peer dependencies)

(Dependencies like `react-spring`, `framer-motion`, `popmotion` are internal and not required for installation.)

2

Optional Dependencies

Install only if using specific components:

  • `chart.js`, `react-chartjs-2`: Required for `DataChart`.
  • `date-fns`: Required for date/time pickers (e.g., `GlassDateRangePicker`). Needs `GlassLocalizationProvider` wrapper.
3

Import & Use Example

Import components and hooks as needed:

// Import components individually for better tree-shaking:
import { GlassButton } from '@veerone/galileo-glass-ui/components/Button'; 
// Or import hooks from the hooks entry point:
import { usePhysicsInteraction } from '@veerone/galileo-glass-ui/hooks';
import styled from 'styled-components';

// Required for 3D tilt effects
const Container = styled.div`perspective: 1000px;`;

function PhysicsButtonExample() {
  const { ref, style } = usePhysicsInteraction({
    animationConfig: 'gentle',
    affectsTilt: true // Enable tilt
  });

  return (
    <Container>
      <GlassButton ref={ref} style={style}>
        Physics Button
      </GlassButton>
    </Container>
  );
}
Installation

Compatibility & Performance

React 19 Ready

Designed for compatibility with React 19 features. (Verify against official release notes if needed).

Bundle Size

Core library ~586KB, but highly tree-shakeable. Use specific imports for best results.

(See optimization docs for details)

Optimization: Tree Shaking

Use specific imports (e.g., `...@veerone/galileo-glass-ui/components/Button`) to minimize bundle size.

Troubleshooting Tips

  • Ensure peer dependency `styled-components` is installed.
  • For 3D tilt effects (`usePhysicsInteraction`), ensure the parent element has a `perspective` CSS property.
  • Check `bugreports.md` in the project for known issues or temporary workarounds.
  • If experiencing issues, try isolating the component or hook in a minimal test case.

Additional Resources

Documentation

Comprehensive guides and API references.

GitHub Repository

Explore the source code, report issues, or contribute.

Community Support

Join discussions and get help.

Browser Compatibility

Galileo Glass UI Documentation

Crafted With Care

Documentation That Inspires

Comprehensive guides that elevate your development experience from ordinary to extraordinary.

Every detail meticulously considered. Our documentation doesn't just explain—it inspires. Discover the possibilities of what you can create with Galileo Glass UI.

View All Documentation