Table of Contents
Architecture is no longer limited to strict shapes and fixed forms. The rise of generative and computational tools has made it possible to design buildings that respond to logic, context, and aesthetics in ways that were once hard to imagine. This post aims to explore this change by designing a facade system in Beegraphy, the online parametric design software. We will then visualize it using Nano Banana’s rendering environment.
The process began with a simple idea: to create a responsive surface that changes shape based on its surroundings, similar to how light, air, or people interact with architectural space. Using BeeGraphy’s node-based workflow, we developed the facade geometry through computational modeling instead of traditional methods. Each panel was adjusted in size, rotation, and depth depending on its distance from a specific point, resulting in a design that appears both purposeful and natural.
To bring this system to life, we placed the model on an existing building and rendered it in Nano Banana. We applied a bronze metallic finish to highlight reflectivity and contrast, capturing the blend of digital fabrication, precision, and artistry.
Concept Development
The facade system that caught my attention was the tessellated triangle design. This made me think, “What if the size of the triangles on the inner side could be controlled by an attractor point? This would let it react dynamically and give the facade a sense of flow and movement.” This idea reflects how environmental elements like light, wind, or human activity shape architecture.
The design started with a simple rectangular grid. This grid divided into triangular panels that act as modular facade elements. Each triangle scales based on its distance from the attractor point. This creates variations in form that look more natural. The responsive pattern makes the surface feel alive: it is dense and compact near the attractor and more open as it moves away.
In BeeGraphy, the attractor logic used nodes to control distance calculation, scaling, and extrusion intensity. The result is a controlled yet organic change in the panels across the facade. The algorithm influences both function and appearance.
A bronze-like metallic material was chosen for the final finish. This choice emphasizes reflectivity and light interaction, achieved through Nano Banana AI by Gemini. The color palette and texture draw inspiration from oxidized metal surfaces often found in architectural cladding, balancing digital precision and material realism.
Beegraphy Workflow
Step 1: Creating the Base Geometry
(Refer to the “Rectangle Group” in the network.)
The process began by generating a rectangular surface that serves as the canvas for the facade.
- Rectangle width and length sliders controlled the overall proportions.
- The rectangle curve was converted to a surface using the Curve to Surface node.
- A Move node paired with Vector XYZ provided flexibility to adjust the plane’s position in 3D space.
This stage established the foundational grid on which the parametric logic would later act.
Step 2: Dividing the Surface into Panels
(Refer to the “Panel” group.)
The next step divided the base surface into smaller, manageable units.
- The surface was split using Partition X and Partition Y, each controlled by numeric sliders to determine the panel density.
- These divisions were then converted into triangular panels using the Triangle Panel A node.
- The Centroid node calculated the geometric center of each triangle, which was essential for mapping distances in later stages.
This created a modular grid of triangles that could be manipulated individually, forming the foundation of the facade’s responsive pattern.
Step 3: Setting Up the Attractor Logic
(Refer to the “Attractor” group.)
The attractor system determined how each triangle would behave based on proximity.
- Two numeric sliders, Distance X and Distance Y, defined the attractor’s position.
- These values were combined using the Construct Point node to create a movable attractor point in space.
- The Distance 2 Points node calculated the distance between each triangle’s centroid and the attractor.
- A Bounds node established the minimum and maximum distance range, which was then remapped to control scaling intensity using Remap Numbers.
- Finally, a Min Inner Scale slider defined how small triangles could get at their closest point.
This logic ensured that panels closer to the attractor scaled down, while those farther away expanded, creating a smooth gradient of variation across the surface.
Step 4: Generating Height and Depth
(Refer to the “Height” group.)
To add three-dimensional expression, vertical displacement was introduced.
- Geometry Closest Point identified the relationship between the attractor and panel points.
- Evaluate Surface and Amplitude Vector nodes controlled how far each triangle would move along the surface normal.
- The Move node translated the geometry vertically based on a Height slider, which set the extrusion intensity.
This step transformed the flat facade into a dynamic surface with depth and contour, enhancing its architectural impact.
Step 5: Scaling Multiple Triangle Sets
(Refer to the “Scaling 3 Sets of Triangles” group.)
To refine the surface variation, scaling was applied across multiple triangle sets.
- Using Range Input and Outer Scale sliders, three scaling operations were defined.
- Each set was processed through separate Scale and Graft Tree nodes, ensuring hierarchical organization of geometry data.
- This layering technique gave the facade richness and dimensional variation, visually amplifying the attractor’s effect.
A link to the original script is provided here.
Rendering with Nano Banana
Importing the Facade and Building
Instead of moving into full 3D rendering, this stage used AI-based visualization to explore how the BeeGraphy-generated facade could sit within a real architectural context. The facade output was exported as an image and placed alongside a building photograph, which acted as the reference environment.
Both visuals were fed into Google Gemini’s Nano Banana, where prompts and masking were used to blend the parametric facade into the building’s left façade section. The goal wasn’t hyper-accurate material simulation but rather a fast, conceptual visualization. The AI interpreted the facade logic and applied a refined metallic-bronze look, capturing the design intent and spatial character without needing manual shader work or detailed 3D setup
Prompt: Apply this attractor-based parametric facade pattern to the building’s surface, making the geometry responsive to a single attractor point with scaled or extruded triangular panels. Follow realistic architectural proportions and preserve the building’s context and lighting. Render the facade with a metallic bronze finish that reflects light subtly, showing variations in depth and tone across the surface. The overall style should look like a professional architectural visualization, with realistic material texture and soft shadows.
Conclusion
This project spotlights how BeeGraphy and Gemini’s Nano Banana bring generative design and real-time visualization together in a simple, browser-based workflow. BeeGraphy enables form-making through parameters and logic, while Nano Banana turns that data-driven geometry into compelling visual narratives. Instead of bouncing between heavy tools, designers can brainstorm, iterate, and present in one fluid loop. It’s a shift from software silos to connected creative ecosystems, making computational design more accessible, intuitive, and expressive for students and professionals alike. As these platforms evolve, expect faster feedback, collaborative workflows, and AI-supported creativity where ideas move from algorithm to atmosphere in minutes.
