298 lines
9.5 KiB
Markdown
298 lines
9.5 KiB
Markdown
---
|
|
name: maximalism
|
|
description: Web and App implementation guide for Controlled Maximalism. Trigger when user wants lots of elements, dense content, but a highly curated and artistic presentation.
|
|
date_added: "2026-06-17"
|
|
risk: safe
|
|
source: self
|
|
source_type: self
|
|
---
|
|
|
|
# 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.
|