Controlled Maximalism

> "Dense and rich, but deeply intentional. Like an exquisitely curated museum of artifacts."

When to Use

Use this sub-style when the user's request matches the aesthetic described above. This is a child reference of the design-it skill and is not meant to be triggered directly.

Core Principles

1. High Density: The screen is packed with information, imagery, and interactive elements.
2. Ornate Detailing: Use of decorative borders, intricate textures, and classic design flourishes.
3. Structured Chaos: Unlike Vibrant Maximalism, the layout here is based on a strict underlying grid that holds the massive amount of content together.

Visual DNA

• Colors: Monochromatic Brown, Yacht Club, or rich jewel tones (emerald, ruby, sapphire, gold).
• Typography: Ornate serifs (like Cinzel or Playfair Display) paired with dense, highly legible sans-serif body copy.
• Borders & Dividers: Extensive use of thin, elegant lines separating every piece of content.

Web Implementation

• Use dense CSS Grid layouts.
• CSS Example:

css
body {
  background-color: #0F172A; /* Deep slate */
  color: #E2E8F0;
  background-image: url('subtle-damask-pattern.png');
}

.max-grid {
  display: grid;
  grid-template-columns: repeat(6, 1fr);
  gap: 16px;
  padding: 16px;
}

.max-item {
  background-color: rgba(30, 41, 59, 0.9); /* Semi-transparent over pattern */
  border: 1px solid #475569;
  padding: 24px;
}

/* Ornate decorative borders */
.max-feature {
  grid-column: span 3;
  border: 2px solid #D4AF37; /* Gold */
  position: relative;
}

.max-feature::before {
  content: '';
  position: absolute;
  top: 4px; left: 4px; right: 4px; bottom: 4px;
  border: 1px dashed #D4AF37;
}

.max-title {
  font-family: 'Cinzel', serif;
  color: #D4AF37;
  font-size: 2.5rem;
  text-align: center;
  border-bottom: 1px solid #475569;
  padding-bottom: 16px;
  margin-bottom: 16px;
}

App Implementation

SwiftUI

swift
struct MaximalismView: View {
    let columns = [
        GridItem(.flexible(), spacing: 4),
        GridItem(.flexible(), spacing: 4),
        GridItem(.flexible(), spacing: 4)
    ]
    
    var body: some View {
        ScrollView {
            LazyVGrid(columns: columns, spacing: 4) {
                // Feature span
                MaxItem(title: "MUSEUM", isFeature: true)
                // Dense data blocks
                MaxItem(title: "1892")
                MaxItem(title: "Vol. II")
                MaxItem(title: "Arch")
                MaxItem(title: "Index")
            }
            .padding(16)
        }
        .background(Color(hex: "0F172A")) // Deep slate
    }
}

struct MaxItem: View {
    let title: String
    var isFeature: Bool = false
    
    var body: some View {
        VStack {
            Text(title)
                .font(.custom("Cinzel", size: isFeature ? 28 : 14))
                .foregroundColor(Color(hex: "D4AF37")) // Gold
                .padding()
        }
        .frame(maxWidth: .infinity, minHeight: isFeature ? 150 : 80)
        .background(Color(hex: "1E293B").opacity(0.9))
        .border(Color(hex: "475569"), width: 1)
        .overlay(
            // Ornate internal dashed border for the feature item
            Group {
                if isFeature {
                    Rectangle()
                        .stroke(style: StrokeStyle(lineWidth: 1, dash: [4]))
                        .foregroundColor(Color(hex: "D4AF37"))
                        .padding(4)
                }
            }
        )
    }
}

• A LazyVGrid with very tight spacing (e.g., 4) creates the necessary density.
• Extensive use of .border and .overlay(Rectangle().stroke(...)) to box in every piece of data, mimicking ornate framing.

Flutter

dart
class MaximalismScreen extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      backgroundColor: const Color(0xFF0F172A),
      body: GridView.count(
        crossAxisCount: 3,
        padding: const EdgeInsets.all(16),
        mainAxisSpacing: 4,
        crossAxisSpacing: 4,
        children: [
          // Flutter's standard GridView doesn't span columns easily.
          // In a real app, use the `flutter_staggered_grid_view` package.
          _buildItem('1892'),
          _buildItem('Vol. II'),
          _buildItem('Arch'),
          _buildItem('Index', isOrnate: true),
          _buildItem('04'),
          _buildItem('XII'),
        ],
      ),
    );
  }

  Widget _buildItem(String title, {bool isOrnate = false}) {
    return Container(
      decoration: BoxDecoration(
        color: const Color(0xFF1E293B).withOpacity(0.9),
        border: Border.all(color: const Color(0xFF475569), width: 1),
      ),
      child: Stack(
        children: [
          if (isOrnate)
            Positioned.fill(
              child: Padding(
                padding: const EdgeInsets.all(4.0),
                // Requires path_drawing or custom painter for dashed borders natively
                child: Container(
                  decoration: BoxDecoration(border: Border.all(color: const Color(0xFFD4AF37), width: 1)),
                ),
              ),
            ),
          Center(
            child: Text(
              title,
              style: const TextStyle(fontFamily: 'Cinzel', color: Color(0xFFD4AF37), fontSize: 16),
            ),
          ),
        ],
      ),
    );
  }
}

• Use flutter_staggered_grid_view to create the complex, spanning "masonry" or architectural grid layouts typical of maximalism.
• Use Stack with Positioned.fill and Padding to create double-bordered framing effects.

React Native

jsx
const MaximalismScreen = () => {
  return (
    <ScrollView style={{ flex: 1, backgroundColor: '#0F172A' }}>
      <View style={{ padding: 16, flexDirection: 'row', flexWrap: 'wrap', gap: 4 }}>
        
        {/* Feature Item spanning full width */}
        <View style={[styles.item, styles.featureItem]}>
          <View style={styles.ornateInnerBorder}>
            <Text style={[styles.text, { fontSize: 32 }]}>MUSEUM</Text>
          </View>
        </View>

        {/* Small Dense Items */}
        <View style={[styles.item, { width: '32%' }]}><Text style={styles.text}>1892</Text></View>
        <View style={[styles.item, { width: '32%' }]}><Text style={styles.text}>Vol. II</Text></View>
        <View style={[styles.item, { width: '32%' }]}><Text style={styles.text}>Arch</Text></View>
      </View>
    </ScrollView>
  );
};

const styles = StyleSheet.create({
  item: {
    backgroundColor: 'rgba(30, 41, 59, 0.9)',
    borderColor: '#475569', borderWidth: 1,
    height: 100, justifyContent: 'center', alignItems: 'center'
  },
  featureItem: {
    width: '100%', height: 200, padding: 4,
  },
  ornateInnerBorder: {
    flex: 1, width: '100%',
    borderColor: '#D4AF37', borderWidth: 1, borderStyle: 'dashed',
    justifyContent: 'center', alignItems: 'center'
  },
  text: {
    fontFamily: 'Cinzel-Regular', color: '#D4AF37', fontSize: 16
  }
});

• A flexWrap: 'wrap' container with percentage widths (e.g., 32% for 3 columns) is the easiest way to build complex, dense grids in React Native.
• Use borderStyle: 'dashed' combined with a solid outer border to create ornate framing.

Jetpack Compose

kotlin
@Composable
fun MaximalismScreen() {
    LazyVerticalGrid(
        columns = GridCells.Fixed(3),
        modifier = Modifier.fillMaxSize().background(Color(0xFF0F172A)).padding(16.dp),
        horizontalArrangement = Arrangement.spacedBy(4.dp),
        verticalArrangement = Arrangement.spacedBy(4.dp)
    ) {
        // Feature spanning all 3 columns
        item(span = { GridItemSpan(3) }) {
            MaxItem("MUSEUM", isFeature = true)
        }
        // Dense items
        items(6) { index ->
            MaxItem("Item $index")
        }
    }
}

@Composable
fun MaxItem(title: String, isFeature: Boolean = false) {
    Box(
        modifier = Modifier
            .height(if (isFeature) 200.dp else 100.dp)
            .background(Color(0xFF1E293B).copy(alpha = 0.9f))
            .border(1.dp, Color(0xFF475569))
            .padding(4.dp),
        contentAlignment = Alignment.Center
    ) {
        if (isFeature) {
            // Ornate inner border
            Box(
                modifier = Modifier
                    .fillMaxSize()
                    .border(1.dp, Color(0xFFD4AF37), shape = RoundedCornerShape(0.dp))
                    // Note: Dashed borders require a custom drawBehind modifier in Compose
            )
        }
        Text(
            text = title,
            color = Color(0xFFD4AF37),
            fontFamily = FontFamily.Serif, // Replace with custom Cinzel font
            fontSize = if (isFeature) 32.sp else 16.sp
        )
    }
}

• LazyVerticalGrid with GridCells.Fixed(3) is perfect.
• Use GridItemSpan(3) for the hero elements to make them span the full width, mimicking editorial or museum layouts.

Do's and Don'ts

• DO: Treat every pixel as valuable real estate. Frame everything.
• DON'T: Let it become unreadable. The contrast between text and background must remain high despite the density.

Limitations

• This is a styling reference and does not replace environment-specific validation, accessibility testing, or expert review.
• Ensure appropriate contrast ratios and responsive behaviors are verified separately.