Parametric Reclaimed Material Wall Designer (PRM WALL DESIGNER PROTOTYPE)

Hello!

This is my first submission (also my first Instructable) for the First Time Author Student Contest, which is super exciting because it’s a chance to actually show off something I made instead of just keeping it on my computer.

I wanted to do something a little unusual: a coding project that lets you design walls using reclaimed materials — like wood scraps, bottles, and metal. Basically, this is a Parametric Reclaimed Material Wall Designer written in Python.

Why This Project?

Walls tell stories — and reclaimed materials give them character. But designing with scraps and irregular materials can be tricky.

This guide walks you through coding a simple tool that procedurally generates unique wall patterns using an “inventory” of reclaimed materials. You’ll end up with a colorful, randomized wall design saved as an image file.

Think of it as a prototype for an eco-design assistant: part coding exercise, part sustainability experiment, and all about creativity.

Supplies

Python 3 installed on your system.

A basic understanding of Python (loops, classes, functions).

The Pillow library for image creation.

Install it by running:

pip install Pillow

Project Setup

Create a folder called wall_designer. (nothing fancy, just right-click → new folder).
Inside it, create a new file named designer.py. (This is where all the code goes.)
Open it in your favorite text editor — this is where we’ll build everything.

👉 Tip: If you’re trying this yourself, name your files clearly. I used designer.py so it’s easy to remember.

Define the Building Blocks (Material Class)

Here’s where I started defining what a “material” even is. For me, each material has a size, a color (so I can actually see it later), and a quantity (because you can’t have infinite scraps of wood lying around, right?).

class Material:

"""Represents a reclaimed material piece."""

def __init__(self, name, width, height, color, quantity):

self.name = name

self.width = width

self.height = height

self.color = color # RGB tuple, e.g. (255, 0, 0) for red

self.quantity = quantity

def __repr__(self):

return f"Material({self.name}, {self.width}x{self.height})"

When I first wrote this, I messed up the color part and forgot it needed to be a tuple (R,G,B).

So if your wall shows up blank, double-check that!

Define the Canvas (Wall Class)

Now, I had to build the actual wall grid.

Think of it like a giant piece of graph paper where each little square can hold a piece of material.

class Wall:

"""Represents the wall and its material placement grid."""

def __init__(self, width, height):

self.width = width

self.height = height

self.grid = [[None for _ in range(width)] for _ in range(height)]

def is_space_available(self, x, y, w, h):

if x + w > self.width or y + h > self.height:

return False

for i in range(y, y + h):

for j in range(x, x + w):

if self.grid[i][j] is not None:

return False

return True

def place_material(self, x, y, material):

for i in range(y, y + material.height):

for j in range(x, x + material.width):

self.grid[i][j] = material

MISTAKE: 🤔 At this point, I actually tried to make the wall bigger than my screen could handle, and my laptop nearly froze.

So yeah… start small first, then scale up.

Procedural Generation Logic

We’ll fill the wall from top-left to bottom-right, randomly choosing from available materials.

This is the fun part — randomness. We don’t want the wall to look the same every time.

import random

def generate_pattern(wall, inventory):

for y in range(wall.height):

for x in range(wall.width):

if wall.grid[y][x] is None:

random.shuffle(inventory)

for material in inventory:

if material.quantity > 0 and wall.is_space_available(x, y, material.width, material.height):

wall.place_material(x, y, material)

material.quantity -= 1

break

return wall

I added random.shuffle() so every time I run the program, the wall looks different. Honestly, this is my favorite part because it feels like the wall is “designing itself.”

Visualize the Wall

Numbers are boring — let’s turn our wall into an image!

So I used Pillow (a Python library for images) to draw colored rectangles for each piece of material.

from PIL import Image, ImageDraw

def create_image(wall, filename="wall_design.png"):

scale = 5

img = Image.new("RGB", (wall.width * scale, wall.height * scale), "white")

draw = ImageDraw.Draw(img)

for y in range(wall.height):

for x in range(wall.width):

material = wall.grid[y][x]

if material:

draw.rectangle(

[x*scale, y*scale, (x+1)*scale, (y+1)*scale],

fill=material.color,

outline="black"

)

img.save(filename)

print(f"✅ Wall design saved as {filename}")

Don't accidentally swap width and height for some materials, and they will look stretched out like gummy worms.

If that happens, check your inputs!

Bring It All Together

This is the “main” section where I created my materials (like wood, bottles, and metal), set the wall size, and told the program to run. (YOU CAN USE YOUR OWN MATERIALS IF YOU FEEL LIKE) {Mine is totally random tbh)

if __name__ == "__main__":

inventory = [

Material("Wood Pallet", 40, 10, (139, 69, 19), 20),

Material("Scrap Metal", 15, 15, (169, 169, 169), 40),

Material("Blue Bottle", 5, 10, (65, 105, 225), 100),

Material("Green Bottle", 5, 5, (0, 128, 0), 150)

]

wall = Wall(120, 80)

print("🔧 Generating wall pattern...")

wall = generate_pattern(wall, inventory)

create_image(wall)

I tried adding “Pink Tiles” just for fun, and it made the wall look like bubblegum. Try your own combos.

Run It!

Open your terminal, navigate to your project folder, and run:

python designer.py

If successful, you’ll see:

✅ Wall design saved as wall_design.png

Check your folder, and admire your unique, procedurally generated wall! Each run gives you a different layout thanks to randomness.

Closing Thoughts

This project is about exploration: how can reclaimed materials and generative design help us think about sustainability differently?

It’s simple, but the idea can grow — you could add textures, optimize placement for stability, or even simulate construction costs. (That I will do for next time!)

For me, this wasn’t just about coding a wall — it was about proving to myself that I could build something unique and share it.

If you’re reading this and thinking, “I don’t know if I can do it,” trust me, you can. I’m 16, I messed up the code like a hundred times, and it still worked out in the end.

So go ahead, grab Python, mess around with it, and create your own designs. Who knows? Maybe your wall design will inspire someone to think differently about materials and sustainability. 🌱