v1.15.0

MaverickWave

Build stunning, responsive websites effortlessly with a modern, lightweight CSS framework crafted for speed, style, and flexibility.

Simple. Adaptive. Unstoppable.

MaverickWave is a sleek foundation for creators who value elegance without compromise. Its fluid design philosophy bends and flexes like the tide - shaping itself perfectly to your vision.

Launch stunning portfolios, vibrant corporate sites, and powerful e-commerce platforms faster than ever. MaverickWave gives you the ultimate creative freedom without sacrificing performance.

Experience the future of styling with effortless dark mode, mobile-first responsive layouts, and accessibility at its core - because great design is for everyone.

Get started

Installation

Add MaverickWave CSS framework to your project using one of these methods:

Option 1: CDN

<link rel="stylesheet" href="https://cdn.jsdelivr.net/gh/m1well/maverick-wave@v1.15.0/maverick-wave.min.css">
<script src="https://cdn.jsdelivr.net/gh/m1well/maverick-wave@1.15.0/maverick-wave.min.js"></script>

Option 2: Direct Download

Integration Options

HTML/CSS
SCSS Projects
Angular
React

Using Pre-compiled CSS (CDN or Download)

This is the simplest method if you don't need SCSS customization. Link the compiled maverick-wave.min.css and maverick-wave.min.js files in your HTML head and before the closing body tag, respectively.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>My MaverickWave Project</title>
    <!-- Framework CSS (CDN or local path) -->
    <link rel="stylesheet" href="path/to/maverick-wave.min.css">
      
    <!-- Your Custom Styles (Load AFTER framework) -->
    <link rel="stylesheet" href="your-custom-styles.css"> 
    <!-- OR -->
    <style>
        /* Custom overrides here */
        :root {
          --mw-primary-color: #your-color; 
          --mw-dark-page-background: #your-color;
          --mw-dark-card-background: #your-color;
          /* ... more overrides ... */
        }
    </style>
</head>
<body>
    <!-- Your content -->
      
    <!-- Framework JS (CDN or local path) -->
    <script src="path/to/maverick-wave.min.js"></script>
</body>
</html>
Customizing via CSS Variables

Even without SCSS, you can customize colors and other properties by overriding the CSS variables defined by MaverickWave. Create your own CSS file (e.g., your-custom-styles.css) or use a <style> tag in your HTML head. Make sure your custom styles are loaded *after* the MaverickWave CSS file.

Override variables within the :root selector:

/* your-custom-styles.css */
:root {
  /* Override base colors */
  --mw-primary-color: #e94560; /* Your brand's primary color */
  --mw-secondary-color: #f39c12;
  --mw-success-color: rgba(26, 188, 156, 0.15); /* Custom success */

  /* Override specific theme colors */
  --mw-dark-page-background: #1a1a2e; /* Custom dark theme page */
  --mw-dark-card-background: #2a2a4a; /* Custom dark theme card */
  --mw-light-page-background: #ffffff; /* Custom light theme page */
  --mw-light-card-background: #f0f0f5; /* Custom light theme card */
        
  /* Override font */
  --mw-font-family-base: 'Your Custom Font', sans-serif; 
}

Refer to the framework's source or documentation for a full list of available CSS variables.

Using SCSS Source Files (Requires Sass Build Process)

For full customization control, integrate MaverickWave's SCSS source files into your project's Sass build process (e.g., using Node Sass, Dart Sass). This allows you to override Sass variables before the framework is compiled.

MaverickWave uses the !default flag for its Sass variables, meaning you can easily set your own values before importing the framework.

1. Configure Theme Mode (Optional)

You can choose the theme behavior during compilation by setting the $mw-theme-mode variable.

  • 'switchable' (Default): Includes styles for both dark (default) and light themes, activated by the .mw-theme-light class and the JS toggle.
  • 'dark': Compiles only the dark theme styles. The theme toggle (if present) will be disabled.
  • 'light': Compiles only the light theme styles. The theme toggle (if present) will be disabled.

Important: Regardless of the chosen theme mode, the main header and navigation bar components currently retain their default dark appearance as defined in the framework.

2. Override Sass Variables

Define your custom variable values in your main Sass file before importing MaverickWave.

3. Import MaverickWave

Import the main framework SCSS file after your overrides.

// Your main project SCSS file (e.g., styles.scss)
    
// --- 1. Configure Theme Mode (Optional) ---
// Options: 'switchable' (default), 'dark', 'light'
$mw-theme-mode: 'switchable'; // this is the default!

// --- 2. Override Framework Sass Variables ---
// Base Colors
$primary-color: #e94560;    // Your brand primary
$secondary-color: #f39c12;  // Your brand secondary
/* and status colors .... */

// Basic background colors
$dark-background: #1f1f2e;
$light-background: #f8f9fa;
    
// Base Text Colors
$dark-text-color: #ffffff;
$light-text-color: #1c1c1c;
    
// Font Family (Ensure you load the font via @font-face)
$font-family: 'Your Custom Font', sans-serif;
    
// You can override entire theme maps if needed
// $dark-theme-colors: (
  'page-background': #your-color,
  'card-background': #your-color,
  'footer-background': #your-color,
  'border': #your-color,
  'shadow': #your-color,
  'text-color': #your-color,
  'text-secondary-color': #your-color,
// );
    
// --- 3. Import MaverickWave Framework ---
// Adjust the path based on your project structure (e.g., node_modules)
@import 'path/to/maverick-wave/scss/maverick-wave';
    
// --- Your Additional Project Styles ---
body {
  // Your custom body styles
}
    

When you compile this Sass file, MaverickWave will use your variable values, and derived colors (like alert backgrounds calculated with color.adjust or rgba in the framework's SCSS) will automatically use your overridden base colors.

Angular Integration

For Angular projects, install via NPM and include in your angular.json:

// Install package
npm install maverick-wave

// In angular.json
"styles": [
  "node_modules/maverick-wave/maverick-wave.min.css",
  "src/styles.scss"
],
"scripts": [
  "node_modules/maverick-wave/maverick-wave.min.js"
]

For SCSS integration in Angular:

// In src/styles.scss
@import 'node_modules/maverick-wave/scss/maverick-wave';

You can also create a theme file to customize variables:

// In src/theme.scss
$primary-color: #3f51b5;
$secondary-color: #ff4081;

@import 'node_modules/maverick-wave/scss/maverick-wave';

React Integration

For React projects, install via NPM and import in your index.js:

// Install package
npm install maverick-wave

// In index.js or App.js
import 'maverick-wave/maverick-wave.min.css';

// If you need the JavaScript functionality
import 'maverick-wave/maverick-wave.min.js';

For SCSS integration in React:

// In your main SCSS file
@import '~maverick-wave/scss/maverick-wave';

Example usage in a React component:

function App() {
  return (
    <div className="mw-container">
      <h1 className="mw-text-primary">Hello, MaverickWave!</h1>
      <p>Start building your awesome React project.</p>
      <button className="mw-btn mw-btn-primary">Get Started</button>
    </div>
  );
}

Adding Custom Fonts

To use custom fonts with MaverickWave, you need to load the font files using the standard CSS @font-face rule and then tell the framework to use your font.

1. Load the Font

Place your font files (e.g., woff2, woff) in your project and define @font-face rules in your custom CSS/SCSS file. Load this CSS early.

/* your-custom-styles.css or your-fonts.scss */

@font-face {
  font-family: 'Your Custom Font';
  src: url('/path/to/your-custom-font.woff2') format('woff2'),
       url('/path/to/your-custom-font.woff') format('woff');
  font-weight: 400; /* Normal weight */
  font-style: normal;
  font-display: swap; /* Improves perceived performance */
}

@font-face {
  font-family: 'Your Custom Font';
  src: url('/path/to/your-custom-font-bold.woff2') format('woff2'),
       url('/path/to/your-custom-font-bold.woff') format('woff');
  font-weight: 700; /* Bold weight */
  font-style: normal;
  font-display: swap;
}

/* Add other weights/styles as needed */
2. Apply the Font

Update the font family used by MaverickWave by overriding either the Sass variable (if using SCSS integration) or the CSS variable (if using CDN/pre-compiled CSS).

SCSS Method (Before @import):

// your-main.scss
$font-family: 'Your Custom Font', /* Fallback fonts */ system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, 'Open Sans', 'Helvetica Neue', sans-serif;

@import 'path/to/maverick-wave/scss/maverick-wave';

CSS Variable Method (In :root):

/* your-custom-styles.css */
:root {
  --mw-font-family-base: 'Your Custom Font', /* Fallback fonts */ system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, 'Open Sans', 'Helvetica Neue', sans-serif;
}

Remember to include appropriate fallback fonts in your font stack.

Documentation

Foundations

Typography

Heading 1

Heading 2

Heading 3

Heading 4

Heading 5
Heading 6
This is a stylish quote with decorative quotation marks.

This is a standard paragraph with default styling. MaverickWave CSS framework uses clean typography with good readability as a foundation for all text elements.

Secondary text uses a slightly muted color for less emphasis, perfect for supporting content, captions, or metadata.

Bold text and italic text are supported as well, allowing for proper content hierarchy and emphasis.

Text can be colored using utility classes to highlight important information or match your brand.

This always remains the text color of the dark theme.

This always remains the text color of the light theme.

Extra Small Text
Small Text
Base Text
Medium Text
Large Text
Extra Large Text

Main Colors

Primary

#000000

Secondary

#000000

Page Background

#000000

Card Background

#000000

Border

#000000

Shadow

#000000

Text

#000000

Text Secondary

#000000

Success

#000000

Warning

#000000

Danger

#000000

Info

#000000

Utilities

Spacing Utilities

No margin bottom
Small margin bottom
Medium margin bottom
Large margin bottom
Small padding
Medium padding
Large padding

Display & Flex Utilities

Flex Row

Item 1
Item 2
Item 3

Flex Column

Item 1
Item 2
Item 3

Alignment

Centered
Centered

Gap Utilities

Different Gap Sizes (from 0 to 10)

Small gap (gap-2)

Item
Item
Item
Item

Medium gap (gap-4)

Item
Item
Item
Item

Large gap (gap-7)

Item
Item
Item
Item

Login

Click “Log In” to simulate a failure and see the red border + message. It will automatically clear after 4 seconds.

Header Utilities

Color Switcher (on a fake header here)

This is not clickable here - because the real color switcher is on top whtihin the header

Your Logo

Localhost Indicator (on a fake header here)

This is what the localhost indicator looks like when it has been activated (so that you can recognise in the header that you are currently working locally)

Your Logo

Coming Soon Banner

Coming Soon

Layout & Navigation

Grid System

MaverickWave CSS framework provides a flexible grid system that adapts to different screen sizes, making responsive layouts simple to implement.

Grid with 2 Columns

Column 1
Column 2

Grid with 3 Columns

Column 1
Column 2
Column 3

Grid with 4 Columns

Column 1
Column 2
Column 3
Column 4

Grid with 5 Columns

Column 1
Column 2
Column 3
Column 4
Column 5

Auto Grid

Auto Column 1
Auto Column 2
Auto Column 3
Auto Column 4
Auto Column 5

Flex Grid

Flex Item 1
Flex Item 2
Flex Item 3

Cards

Standard Cards

Tech Image

Featured Article

This is the subtitle of this card in secondary text color

Cards are versatile containers for displaying related content and actions. This example shows an image card with a title and descriptive text.

Project Update

A simple card without an image works well for text-focused content. Use cards to organize information into digestible sections with clear visual hierarchy.

Development Stack

Cards can include various components like tags to categorize content. This example shows how to display technologies used in a project.

HTML CSS JavaScript

Team Member Profile

Cards work well for displaying team information with skills and expertise. Add tags to highlight specific areas of specialization.

UI Design Frontend Accessibility

Tech-Stack Cards

Frontend
React TypeScript Next.js Tailwind CSS

Building responsive, accessible, and performant user interfaces

Backend
Node.js Express NestJS GraphQL

Developing scalable APIs and server-side applications

Data Storage
MongoDB PostgreSQL Redis Prisma

Managing structured and unstructured data with the right tools

DevOps & Cloud
Docker GitHub Actions AWS Vercel

Automating deployment and scaling applications in the cloud

Testing & Quality
Jest Cypress ESLint Prettier

Ensuring code quality and reliability through automated testing

Large Cards

If you have a image and want to display the entire image, replace the standard mw-card-img class with mw-card-img-contain in your card markup. This alternative style ensures the complete image is visible while maintaining centering and proportions. (See the first large and the second extra large card)

Portrait Style Image

Large Card

Large cards feature taller images (330px height) that work well for portrait-oriented photos or when you want to showcase more of your visual content.

Portrait Style Image

Team Member

Large cards are perfect for team profiles, product features, or any content where the image deserves more prominence in your layout.

Design UX Research Prototyping

Extra Large Cards

Here you can see the difference in portrait images between the standard mw-card-img class on the first image and mw-card-img-contain class on the second image.

Portrait Style Image

Featured Profile

This is the subtitle of this card in secondary text color

Extra large cards with 480px image height are ideal for portrait photography, profile spotlights, or when the visual element is the primary focus of your content.

Portrait Style Image

Artist Spotlight

The extra large card format creates a dramatic visual impact, making it perfect for highlighting key people, products, or artistic content in your application.

Card Variations

Card with Tags

Tags can be used to categorize content or show related topics.

Primary Success Danger

Card with Avatar

User Avatar

Sarah Johnson

Product Designer

Cards can include avatars to represent users or team members.

Card with Progress

Include progress bars to show completion status or metrics.

Project Status 70

Panels

Default Panel

This is a default panel with header, body, and footer sections. Panels are useful for grouping related content.

Primary Panel

This is a primary panel with a colored header. You can use different panel variants to indicate different types of content.

Secondary Panel

This is a secondary panel with a colored header. Panels can contain any type of content, including forms, tables, or other components.

Scrollable Panel

This panel has a fixed maximum height of 500px and will scroll when content exceeds this height. Scrollable panels are ideal for displaying large amounts of content in a constrained space.

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nullam in dui mauris.

Vivamus hendrerit arcu sed erat molestie vehicula. Sed auctor neque eu tellus.

Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae.

Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas.

Ut aliquam sollicitudin iaculis. Praesent ac semper ante. Interdum et malesuada fames ac ante ipsum primis in faucibus.

Mauris egestas elit vel nunc maximus, in aliquam magna vehicula. Cras vitae sapien a erat facilisis faucibus.

Donec dignissim, odio ac imperdiet luctus, elit lorem eleifend massa, sed efficitur turpis velit vel odio.

Suspendisse potenti. Nullam gravida fermentum turpis eu ultrices. Curabitur imperdiet imperdiet lacus.

Praesent ac semper ante. Interdum et malesuada fames ac ante ipsum primis in faucibus.

Medium Height Panel

This panel uses the medium height variant (500px) and will scroll when content exceeds this height.

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nullam in dui mauris.

Vivamus hendrerit arcu sed erat molestie vehicula. Sed auctor neque eu tellus.

Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae.

Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas.

Ut aliquam sollicitudin iaculis. Praesent ac semper ante. Interdum et malesuada fames ac ante ipsum primis in faucibus.

Mauris egestas elit vel nunc maximus, in aliquam magna vehicula. Cras vitae sapien a erat facilisis faucibus.

Donec dignissim, odio ac imperdiet luctus, elit lorem eleifend massa, sed efficitur turpis velit vel odio.

Small Height Panel

This panel uses the small height variant (300px) and will scroll when content exceeds this height. Ideal for compact UI elements.

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nullam in dui mauris.

Vivamus hendrerit arcu sed erat molestie vehicula. Sed auctor neque eu tellus.

Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae.

Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas.

Ut aliquam sollicitudin iaculis. Praesent ac semper ante. Interdum et malesuada fames ac ante ipsum primis in faucibus.

Tabs

Default Tabs

Features
Specifications
Reviews
Support

Key Features

MaverickWave CSS framework provides a comprehensive set of features to make your web development faster and more efficient:

  • Responsive grid system with flexible layouts
  • Customizable components with consistent design language
  • Dark and light theme support with smooth transitions
  • Utility classes for rapid development and prototyping
  • Modern design aesthetic with attention to detail

Technical Specifications

MaverickWave CSS framework is built with modern web standards in mind:

  • Built with SCSS for better organization and maintainability
  • Optimized file size (under 30KB minified and gzipped)
  • Compatible with all modern browsers (Chrome, Firefox, Safari, Edge)
  • No JavaScript dependencies for core functionality
  • CSS custom properties for easy theming and customization

User Reviews

Alex T. - Frontend Developer

"MaverickWave CSS framework has simplified my workflow tremendously. The components are well-designed and the utility classes save me hours of custom CSS writing. The documentation is clear and comprehensive."

Jamie L. - UX Designer

"I love how easy it is to customize the framework to match my brand. The dark/light theme toggle was a breeze to implement and my clients are impressed with the polished look!"

Support Options

I offer multiple support channels for MaverickWave:

  • Comprehensive documentation
  • Regular updates with new features and improvements
  • Dedicated support for power users

Vertical Tabs

Getting Started
Configuration
Customization
Best Practices

Getting Started Guide

Begin by creating a new project folder:

mkdir my-project cd my-project touch index.html styles.css

Add the CSS to your HTML:

<link rel="stylesheet" 
href="path/maverick-wave.min.css">

Configuration Options

MaverickWave offers flexibility in how you configure and customize its appearance. The primary methods involve overriding CSS variables or, for deeper integration, overriding Sass variables during a build process.

Theme Mode (SCSS Build Only)

If using the SCSS source files, you can control the theme output by setting the $mw-theme-mode variable before importing the framework:

  • 'switchable' (Default): Includes dark and light themes, controlled by JS.
  • 'dark': Compiles only dark theme styles.
  • 'light': Compiles only light theme styles.
// Your main.scss
$mw-theme-mode: 'switchable'; // Or 'dark', 'light'    
@import 'path/to/maverick-wave/scss/maverick-wave';

Note: The main header/navigation currently retains its default dark appearance regardless of this setting.

Color & Font Overrides

See the "Customization" tab for details on overriding colors and fonts using either CSS or SCSS variables.

Customization Guide

Choose the customization method that best suits your project setup:

Method 1: CSS Variable Overrides

Ideal for CDN/pre-compiled CSS usage. Define overrides in your own CSS file (loaded after MaverickWave):

/* your-custom-styles.css */
:root {
  --mw-primary-color: #e94560; 
  --mw-dark-page-background: #1a1a2e; 
  --mw-font-family-base: 'Your Custom Font', sans-serif; 
  /* ... other overrides ... */
}
Method 2: SCSS Variable Overrides

Requires a Sass build process. Define overrides in your main SCSS file before importing MaverickWave:

// your-main.scss
$primary-color: #e94560;
$font-family: 'Your Custom Font', sans-serif;
// ... other overrides ...
    
@import 'path/to/maverick-wave/scss/maverick-wave';

This method allows framework-internal calculations (like derived alert backgrounds) to use your custom base colors.

Adding Custom Fonts

Remember to load custom fonts using @font-face rules in your CSS/SCSS before applying them via the --mw-font-family-base or $font-family variable.

Refer to the "Get Started" section for more detailed examples.

Best Practices

When working with MaverickWave:

  • Use semantic HTML elements for better accessibility
  • Leverage utility classes for quick adjustments
  • Customize variables to match your brand identity
  • Test thoroughly across different browsers and devices
  • Consider performance by only including components you need

Pills Style Tabs

Dashboard
Profile
Messages
Settings

Dashboard Overview

Welcome to your dashboard! Here you can monitor key metrics, recent activity, and important notifications at a glance.

User Profile

Manage your profile information, update your avatar, and customize your bio and contact details.

Message Center

View and respond to messages from your team members. Organize conversations and track important communications.

Account Settings

Configure your account preferences, notification settings, privacy options, and security features.

Accordions

What is MaverickWave?

MaverickWave is a lightweight, responsive CSS framework designed for modern web development. It provides a clean foundation with customizable components and utility classes to help you build beautiful, responsive websites quickly.

How do I customize MaverickWave?

MaverickWave offers two main ways to customize its appearance to match your project's needs:

1. Using CSS Variables (Recommended for CDN/CSS Users)

If you're using the pre-compiled CSS file (via CDN or download), you can override MaverickWave's default styles by redefining its CSS variables in your own stylesheet (loaded *after* MaverickWave's CSS).

/* Your custom-styles.css */
  :root {
    /* Override base colors */
    --mw-primary-color: #e94560; 
    --mw-secondary-color: #f39c12;
  
    /* Override specific theme colors */
    --mw-dark-page-background: #1a1a2e; 
    --mw-light-card-background: #f0f0f5; 
  
    /* Override component variables */
    --mw-alert-primary-bg: rgba(233, 69, 96, 0.15);
  
    /* Override font */
    --mw-font-family-base: 'Your Custom Font', sans-serif; 
  }

This method is flexible and doesn't require a Sass build process.

2. Using SCSS Variables (Requires Sass Build Process)

If you integrate MaverickWave's SCSS source files into your project, you can override the framework's default Sass variables before importing it. This gives you deeper control and allows derived colors (calculated using Sass functions like rgba() or color.adjust() within the framework) to automatically use your custom base colors.

// Your main.scss
  
  // Override Sass variables BEFORE importing
  $primary-color: #e94560;
  $font-family: 'Your Custom Font', sans-serif;
  $mw-theme-mode: 'dark'; // Optionally set theme mode
  
  // Import MaverickWave
  @import 'path/to/maverick-wave/scss/maverick-wave';

This method requires you to have a Sass compiler set up in your project.

See the "Get Started" section for more detailed integration examples for both methods.

Is MaverickWave responsive?

Yes, MaverickWave CSS framework is fully responsive and works on all devices. It uses a mobile-first approach with responsive breakpoints for different screen sizes, ensuring your website looks great on phones, tablets, laptops, and desktops.

Scrollable Content Example

This accordion panel demonstrates scrollable content when the content exceeds the available space. This is useful for displaying large amounts of information in a compact format.

Accordions are excellent UI components for FAQs, product details, or any content that benefits from progressive disclosure. They help reduce cognitive load by showing only the most relevant information at first.

When designing with accordions, consider these best practices:

  • Use clear, descriptive headers that indicate the content inside
  • Keep content concise and focused on a single topic per panel
  • Consider whether users need to compare information across panels
  • Ensure keyboard accessibility for navigation
  • Provide visual feedback for interactive elements

MaverickWave accordions are designed with accessibility in mind, ensuring they work well with screen readers and keyboard navigation. The smooth animations provide visual feedback without being distracting.

You can customize the appearance of accordions using CSS variables to match your brand colors and design language. The component is built with flexibility in mind.

For more complex use cases, you can nest accordions or combine them with other components like tabs or cards to create rich, interactive interfaces that guide users through complex information hierarchies.

Lists

Basic List

  • First item
  • Second item
  • Third item
    • Nested item 1
    • Nested item 2
  • Fourth item

Unstyled List

  • First item
  • Second item
  • Third item
  • Fourth item

Inline List

  • First item
  • Second item
  • Third item
  • Fourth item

Links List

Dot List

  • First item with dot
  • Second item with dot
  • Third item with dot

Check List

  • First completed item
  • Second completed item
  • Third completed item

Components

Progress Bars

Basic Progress Bars

Default (75%)

Project Completion 75

Without Info (50%)

Hidden 50

With scale 1-10

User Rating 7

With inline label (55%)

55%

Colored Progress Bars

Primary (60%)

Downloads 60

Secondary (50%)

Uploads 50

Success (100%)

Task Complete 100

Warning (30%)

Disk Space 30

Danger (15%)

Battery 15

Sizable Progress Bars

Small Progress (65%)

Small 65

Default (65%)

Default 65

Large (65%)

Large 65

Loding Spinners

Basic Spinners

Border Spinner

Dots Spinner

Dual Ring Spinner

Spinner Sizes

Small

Default

Large

Spinner Colors

Default

Primary

Secondary

Spinner in Context

Overlay Spinner

This card demonstrates a loading overlay with a spinner.

The content remains visible but appears disabled during loading states, providing clear visual feedback to users while data is being processed.

Avatars

Avatar Sizes

Avatar
Avatar
Avatar
Avatar
Avatar

Avatar Shapes & Colors & Group

Avatar Shapes

Avatar
Avatar

Avatar Colors

Avatar
Avatar
Avatar
Avatar
Avatar
Avatar

Avatar Group

Avatar
Avatar
Avatar
Avatar

Tags

Basic Tags

Default Tags

HTML CSS JavaScript React Node.js

Primary Tags

HTML CSS JavaScript

Secondary Tags

HTML CSS JavaScript

Tag Sizes & Icons

Small Tags

Small Tag Size

Default Size

Default Tag Size

Large Tags

Large Tag Size

Tags with Icons

HTML CSS JavaScript

Action Tags

Closable Tags

Frontend Design

Ratings

Change the data-rating attribute (0–5) to see how many thumbs-up light up. You can also determine the icon flexibly.

Ratings in different sizes

User Rating (size SM)

Product Rating

Movie Rating (size LG)

Ratings with other icons

Product Rating

Product Rating

Product Rating

Product Rating

Product Rating

Alerts

Primary Alert

This is a primary alert—providing important information to users.

×

Secondary Alert

This is a secondary alert—useful for notifications that don't require immediate attention.

×

Success Alert

This is a success alert—confirming that an action has been completed successfully.

×

Warning Alert

This is a warning alert—highlighting potential issues that require attention.

×

Danger Alert

This is a danger alert—indicating critical issues that need immediate attention.

×

Info Alert

This is an info alert—providing helpful context or additional information to users.

×

Counters

Counter Sizes

5
Projects Completed
12
Years of Experience
98
Happy Clients

Counter Color Variants

24/7
Customer Support
30
Years old

Code

Inline Code

Use inline code for variables, function names, or short code snippets within your text.

For example, use mw-btn class to create a button or mw-card to create a card component in your layout.

Code Block

Use code blocks for multi-line code examples:

// A simple greeting function
function greet(name) {
  return `Hello, ${name}!`;
}

// Display greeting in console
console.log(greet('Developer'));

Code Block with Filename

counter.jsx React
// A simple React counter component
import { useState } from 'react';

function Counter() {
  const [count, setCount] = useState(0);
  return (
    ......
  );
}

Terminal

cd my-project touch index.html styles.css script.js Created 3 files mkdir assets ls -la

Syntax Highlighting (Integration)

MaverickWave provides styling for code containers (.mw-code-block, .mw-code-container) and basic styles for common code tokens (like keywords, comments, strings) using classes such as .mw-code-keyword, .mw-code-comment, etc.

However, MaverickWave does not include a built-in JavaScript library for automatically parsing code and applying these highlighting classes.

Option 1: Manual Highlighting

For simple snippets, you can manually wrap parts of your code with <span> tags using the provided .mw-code-* classes:

manual-example.js JavaScript
const greet = (name) => {
  // Simple greeting
  return `Hello, ${name}!`;
};
Option 2: Using a Syntax Highlighting Library

For automatic highlighting of various languages, integrate a dedicated JavaScript library like Prism.js or Highlight.js.

  1. Include the library's CSS and JavaScript files in your project.
  2. Ensure the library is configured to process code within MaverickWave's <pre><code>...</code></pre> structures, often by adding specific language classes (e.g., <code class="language-javascript">).
  3. You might need to slightly adjust the library's theme or MaverickWave's token styles (.mw-code-*) for perfect visual integration, or simply rely entirely on the chosen library's theme.

Using an external library is recommended for robust, multi-language syntax highlighting.

Using Code Components

Basic Structure

Here's how to structure the HTML for MaverickWave's code components:

Inline Code
<p>Use the <code>mw-btn</code> class.</p>
Basic Code Block
<div class="mw-code-container">
  <pre><code>your_code_here();
    more_code();</code></pre>
</div>
Code Block with Header
<div class="mw-code-block"> <!-- Note: .mw-code-block wraps header + container -->
  <div class="mw-code-block-header">
    <span class="mw-code-block-filename">script.js</span>
    <span class="mw-code-block-language">JavaScript</span>
  </div>
  <div class="mw-code-container">
    <pre><code>your_code_here();</code></pre>
  </div>
</div>
Terminal Block
<div class="mw-terminal">
  <span class="mw-terminal-line">npm install maverick-wave</span>
  <span class="mw-terminal-line mw-terminal-output">+ maverick-wave added</span>
</div>

Remember to integrate a syntax highlighting library if you need automatic language coloring (see the "Syntax Highlighting" section above).

Data & Display

Tables

Basic Table

This is the basic table that supports all functions except the complete responsive feeling with the cards

# Name Position Location
1 John Doe Developer New York
2 Jane Smith Designer London
3 Bob Johnson Manager Berlin

Compact Table

Same table as basic table but a bit with less spacing and smaller fonts

# Name Position Location
1 John Doe Developer New York
2 Jane Smith Designer London
3 Bob Johnson Manager Berlin

Responsive Table

This is the same table but with cards for smaller screens

# Name Position Location
1 John Doe Developer New York
2 Jane Smith Designer London
3 Bob Johnson Manager Berlin

Blog Posts

Just a dummy blog post

UI/UX design

The landscape of web development continues to evolve at a rapid pace. In this article, we explore the latest frameworks, tools, and methodologies that are shaping the industry in 2025.

The Rise of AI-Assisted Development

Artificial intelligence has transformed how we approach coding. Modern IDEs now come equipped with sophisticated AI assistants that can generate entire components, optimize performance, and even identify potential bugs before they manifest.

The most significant advancement has been in the realm of natural language programming, where developers can describe functionality in plain English and have the AI generate the corresponding code.

"AI hasn't replaced developers; it has elevated them. We now spend more time on architecture and problem-solving rather than writing boilerplate code." — Elena Vega, Lead Developer at TechFront

Serverless Architecture: Beyond the Basics

Serverless computing has matured significantly, moving beyond simple function execution to comprehensive application architectures. The new generation of serverless platforms offers:

  • Stateful serverless functions with built-in memory persistence
  • Edge-optimized execution for global performance
  • Integrated database connections with automatic scaling
  • Real-time monitoring and debugging capabilities

Code Example: Modern Serverless Function

// Modern serverless function with state management
export async function handler(event, context) {
  // Access persistent state across invocations
  const state = await context.getState();

  // Process the incoming request
  const result = processRequest(event, state);

  // Update the state for future invocations
  await context.setState({
    lastProcessed: new Date(),
    counter: (state.counter || 0) + 1,
    recentRequests: [...(state.recentRequests || []), event.id].slice(-10)
  });

  return {
    statusCode: 200,
    body: JSON.stringify(result)
  };
}

Web Components and Micro-Frontends

The component-based architecture has evolved into a more standardized approach with Web Components becoming the foundation of modern frontend development. This has enabled true interoperability between different frameworks and libraries.

Micro-frontends have also gained widespread adoption, allowing teams to develop, test, and deploy parts of a frontend independently, using different technologies if necessary.

Conclusion

As we move further into 2025, the web development landscape continues to prioritize developer experience, performance, and scalability. By embracing these modern techniques, developers can create more robust, efficient, and maintainable applications.