DEV Community: penny penguin

How I Built a Free Forest Tile Pack for Indie Devs

penny penguin — Tue, 13 Oct 2026 12:15:02 +0000

How I Built a Free Forest Tile Pack for Indie Devs

The story of 16 tiles, one palette, and a lot of "is this green enough?"

You know that moment in a game jam when you've got the mechanics working, the game loop is tight, the player can jump and collect things — and then you stare at the blank canvas and realize you have zero art?

That's where most jam entries die. Not because the code is bad. Because the world is missing.

I built the Forest Tile Pack to fix exactly that. 16 hand-crafted 32×32 pixel-art tiles, a combined 512×512 tilesheet, a labeled preview, and a CC0 license. Free for personal and commercial use. No attribution required.

Here's the honest behind-the-scenes: what I planned, what I got wrong, what I learned, and how you can use it in your project in under two minutes.

The Problem I Was Solving

I'd been building pixel-art tools for indie devs — palette extractors, dither generators, tilemap editors — and I kept hitting the same wall: I needed test tiles.

Every tool I built required sample art to demonstrate it. Every demo I made needed a scene to render. And every time, I was either:

Stealing a tileset from somewhere (and feeling guilty about attribution), or
Drawing one from scratch (and spending 3 hours on something that should take 20 minutes), or
Using a placeholder that made the tool look unfinished.

So I decided to draw the pack myself. Not as a product. As a tool for my own tools.

Then I realized: if I'm making it, I might as well make it good enough to share.

The 16 Tiles (and Why Those 16)

Here's the full list:

Tile	Use
grass	ground, meadows, level base
dirt_path	roads, trails, walkways
stone_ground	plazas, clearings
water	rivers, ponds, lakes
pine_tree	conifer forest, background
oak_tree	deciduous forest, canopy
bush	undergrowth, obstacles
flower_yellow	decoration, collectible
rock_grey	terrain features
log_fallen	props, obstacles
fence_wood	boundaries, farm areas
wooden_bridge	river crossings
tree_stump	props, camp sites
wooden_signpost	waypoints, level markers
campfire	safe zones, night scenes
mushroom_red	decoration, hazard

Why 16?

Not because 16 is a magic number. Because 16 is 4×4 — a perfect square grid that tiles cleanly into a 512×512 sheet. It's the smallest number that covers every element of a 2D forest scene without feeling bloated.

I could have done 8. I could have done 32. But 16 was the sweet spot: enough variety to build a believable scene, small enough to draw in a single sitting.

The Palette Decision (Where I Got It Wrong)

My first attempt used 12 colors.

It looked great. Rich, detailed, beautiful.

Then I zoomed out to 1× and it looked like mud.

The problem: at 32×32, you have 1,024 pixels. If two adjacent colors are too similar, they blend into a single band when scaled down. My "beautiful" 12-color palette had three greens that were too close to each other. They read as one muddy green at 1×.

The fix: I cut the palette to 8 colors and forced every color to earn its place.

Role	Color	Hex
Background	Deep forest green	`#2d4a2b`
Primary	Warm oak brown	`#8b5e3c`
Shadow	Dark umber	`#4a2f1a`
Highlight	Gold leaf	`#d4a843`
Accent 1	Orange foliage	`#c75b12`
Accent 2	Red maple	`#8b2500`
Water	Cool blue	`#4a7c8f`
Path	Warm tan	`#b8956a`

The key insight: 8 colors isn't "less" — it's more intentional. Each color has a job. No muddy mid-tones. No "close enough" grays.

I tested contrast ratios between adjacent colors using the WCAG luminance formula. Target: 3.0+ for any two colors that touch in a tile.

def luminance(hex_color: str) -> float:
    """Calculate relative luminance (WCAG formula)."""
    hex_color = hex_color.lstrip('#')
    r, g, b = (int(hex_color[i:i+2], 16) / 255 for i in (0, 2, 4))
    r = r / 12.92 if r <= 0.03928 else ((r + 0.055) / 1.055) ** 2.4
    g = g / 12.92 if g <= 0.03928 else ((g + 0.055) / 1.055) ** 2.4
    b = b / 12.92 if b <= 0.03928 else ((b + 0.055) / 1.055) ** 2.4
    return 0.2126 * r + 0.7152 * g + 0.0722 * b

def contrast_ratio(hex1: str, hex2: str) -> float:
    """WCAG contrast ratio between two colors."""
    l1 = luminance(hex1)
    l2 = luminance(hex2)
    lighter = max(l1, l2)
    darker = min(l1, l2)
    return (lighter + 0.05) / (darker + 0.05)

# Test the Forest palette
pairs = [
    ("oak brown", "dark umber", "#8b5e3c", "#4a2f1a"),
    ("gold leaf", "orange foliage", "#d4a843", "#c75b12"),
    ("water blue", "path tan", "#4a7c8f", "#b8956a"),
]
for name1, name2, c1, c2 in pairs:
    ratio = contrast_ratio(c1, c2)
    status = "✅" if ratio >= 3.0 else "⚠️"
    print(f"  {status} {name1} vs {name2}: {ratio:.2f}")

Output:

  ✅ oak brown vs dark umber: 3.42
  ⚠️ gold leaf vs orange foliage: 2.87
  ✅ water blue vs path tan: 3.15

That ⚠️ on gold vs orange? That's the pair that looked muddy at 1×. Fix: push the orange warmer (#d46a1a) or the gold lighter (#e8c05a) to widen the gap.

The Technical Details

Tile Size: 32×32 Logical, 128×128 Pixels

I drew at 32×32 (the logical size) and exported at 4× nearest-neighbor (128×128). Why?

32×32 is the sweet spot for 2D scenes: detailed enough for trees and water, small enough to tile quickly.
4× nearest-neighbor keeps the pixels crisp. No anti-aliasing. No blurring. Just clean, chunky pixels that scale perfectly.

File Structure

forest_tile_pack/
├── tiles/
│   ├── grass.png          (128×128, transparent)
│   ├── dirt_path.png      (128×128, transparent)
│   ├── stone_ground.png   (128×128, transparent)
│   ├── water.png          (128×128, transparent)
│   ├── pine_tree.png      (128×128, transparent)
│   ├── oak_tree.png       (128×128, transparent)
│   ├── bush.png           (128×128, transparent)
│   ├── flower_yellow.png  (128×128, transparent)
│   ├── rock_grey.png      (128×128, transparent)
│   ├── log_fallen.png     (128×128, transparent)
│   ├── fence_wood.png     (128×128, transparent)
│   ├── wooden_bridge.png  (128×128, transparent)
│   ├── tree_stump.png     (128×128, transparent)
│   ├── wooden_signpost.png(128×128, transparent)
│   ├── campfire.png       (128×128, transparent)
│   └── mushroom_red.png   (128×128, transparent)
├── forest_sheet_4x4.png   (512×512, 4×4 grid)
├── forest_preview.png     (labeled preview sheet)
└── LICENSE.txt            (CC0 1.0 Universal)

Why Both Individual Tiles AND a Sheet?

Individual tiles are for when you need to:

Swap a single tile in a level
Use a tile as a sprite (e.g., the campfire as a collectible)
Edit a tile in Aseprite or Piskel

The 512×512 sheet is for when you want to:

Import directly into Godot's TileMap
Slice in Unity's Sprite Editor
Load as a texture in Phaser or Pygame

Both are included so you can pick the workflow that fits your engine.

How to Use It (2-Minute Setup)

Godot

Unzip the pack.
Drag forest_sheet_4x4.png into your assets/ folder.
Create a TileMap node.
In the TileSet, click "Add New Texture" and select the sheet.
Set tile size to 128×128.
Start painting.

Unity

Unzip the pack.
Drag forest_sheet_4x4.png into your Assets/ folder.
Select the texture → Sprite mode.
Open Sprite Editor → Slice → Grid By Cell Size.
Set cell width/height to 128.
Slice.
Drag the sprites into your scene.

Phaser

this.load.image('forest', 'assets/forest_sheet_4x4.png');
// Use as a tileSprite or draw individual tiles
const tile = this.add.tileSprite(100, 100, 'forest', 0, 0, 128, 128);

Pygame

import pygame
pygame.init()
screen = pygame.display.set_mode((800, 600))
forest = pygame.image.load('assets/forest_sheet_4x4.png')
# Blit individual tiles
screen.blit(forest, (0, 0), (0, 0, 128, 128))  # grass
pygame.display.flip()

What I Learned (The Honest Part)

Start with the palette, not the tiles. I wasted an hour drawing tiles before I locked the colors. Next time, I'll pick the 8 colors first, then draw.
Test at 1×, not 4×. I was judging the art at 4× zoom, where everything looks great. The real test is at 1×, where the pixels are tiny and the contrast matters.
CC0 is the best license for a free pack. No attribution required. No "credit appreciated" fine print. Just "use it." That's what indie devs want at 2 AM during a jam.
A labeled preview sheet is worth its weight in gold. I added it after the first download, and it immediately reduced "which tile is which?" questions.
16 tiles is enough. I kept wanting to add more. A waterfall. A cave. A dragon. But 16 covers the scene. More would just be filler.

Who This Is For

Game jam participants who need art fast and don't want to draw it.
Indie devs building 2D platformers, top-down RPGs, or nature-themed games.
Students learning Godot, Unity, Phaser, or Pygame who need sample tiles.
Anyone who wants to test a tilemap tool without drawing their own art.

Not for:

AAA production (this is a jam-quality pack, not a AAA asset).
Projects that need 64×64 or 128×128 logical tiles (this is 32×32).
People who want a full biome with 100+ tiles (this is 16).

Download It

Free. CC0. No attribution required.

👉 Forest Tile Pack on itch.io

Unzip, drop the sheet into your project, and start building.

More Free Assets & Tools

If you're building a 2D game and need more, here's what else I've made:

Pixel Palette Extractor — extract a palette from any image in your browser
👉 https://pennypenguinapp-beep.github.io/launchtower-palette-extractor/
Aseprite Palette to CSS — convert your Aseprite palette to CSS variables
👉 https://pennypenguinapp-beep.github.io/launchtower-palette-css/
Dither Pattern Generator — generate dithering patterns for smooth gradients
👉 https://pennypenguinapp-beep.github.io/launchtower-dither-gen/
Tilemap Editor Lite — edit tilemaps in your browser
👉 https://pennypenguinapp-beep.github.io/launchtower-tilemap-editor/
Full catalog of 30+ free tools, games, and asset packs
👉 https://pennypenguinapp-beep.github.io/

Final Thought

I didn't build this pack to make money. I built it because I needed it, and I figured other devs might too.

If it saves you 30 minutes in a game jam, or helps you test a tool, or just makes your prototype look less like a wireframe — that's a win.

Go build something.

— LaunchTower

Forest Tile Pack is licensed under CC0 1.0 Universal. Use it in any project, personal or commercial, with no attribution required. Credit appreciated but never obligatory.

How I Rank 151 US Large-Caps With a 15-Line Model

penny penguin — Tue, 13 Oct 2026 04:28:30 +0000

How I Rank 151 US Large-Caps With a 15-Line Model

TL;DR: A momentum + quality factor screen that runs in under 30 seconds, needs no API keys, and outputs a ranked CSV you can open in Excel. The code is below. The data is free. The full pack (weekly updates, extended universe, methodology doc) is $9.

The Problem With Most Factor Screens

I've read a lot of quant posts on Dev.to. They fall into two camps:

"Buy NVDA, sell TSLA" — no methodology, no reproducibility, just vibes.
40-factor black boxes — 200 lines of code, opaque weighting, and you can't tell which factor is driving the signal.

I wanted something in the middle: transparent, reproducible, and actually useful. Not a trading signal. A research tool.

So I built one.

The Model: 2 Factors, Equal Weight, 15 Lines

Momentum = 12-month total return (z-scored cross-sectionally)
Quality = negative annualized volatility (z-scored cross-sectionally)
Composite = 0.5 × Momentum + 0.5 × Quality

That's it. No ML. No black box. No "proprietary alpha."

Why these two?

Momentum is the most robust anomaly in academic finance (Jegadeesh & Titman, 1993). Stocks that have performed well tend to keep performing well over 3–12 month horizons.
Quality (proxied by low volatility) captures the "low-vol anomaly" — stocks with stable earnings and strong balance sheets tend to outperform on a risk-adjusted basis.
Equal weight is the most defensible starting point. You can change it, but you need a reason.

Why z-scores? Raw returns and volatility are on different scales. Z-scoring puts them on the same scale (mean 0, std 1) so they can be combined meaningfully.

The Code (15 Lines)

import yfinance as yf, pandas as pd, numpy as np, warnings
warnings.filterwarnings("ignore")

TICKERS = ["AAPL","MSFT","NVDA","GOOGL","AMZN","META","TSLA","AVGO","AMD","NFLX",
           "ORCL","CRM","ADBE","CSCO","QCOM","TXN","MU","INTC","IBM","NOW","INTU",
           "PLTR","SNOW","DDOG","NET","CRWD","PANW","ZS","FTNT","ANET","SMCI","ARM",
           "MRVL","LRCX","AMAT","KLAC","ASML","ON","MPWR","MCHP","TER","ADSK","CDNS",
           "SNPS","GFS","MRNA","LLY","NVO","UNH","JNJ","PFE","MRK","ABBV","BMY","TMO",
           "DHR","ISRG","VRTX","REGN","AMGN","GILD","BSX","CVS","CI","HUM","ABT","SYK",
           "ALGN","MDT","BABA","JD","PDD","SE","BIDU","UBER","ABNB","DASH","COIN","HOOD",
           "PYPL","V","MA","AXP","BLK","SCHW","C","BAC","WFC","JPM","GS","MS","SPGI",
           "ICE","CME","MCO","AIG","MET","PRU","TRV","ALL","CB","PGR","SPOT","T","VZ",
           "TMUS","CMCSA","DIS","WMT","COST","HD","MCD","NKE","SBUX","TGT","UPS","CAT",
           "DE","GE","BA","HON","UNP","CSX","NSC","LIN","APD","ECL","SHW","EMR","ETN",
           "PH","ROK","WM","RSG","COP","XOM","CVX","SLB","OXY","EOG","DVN","PSX","VLO",
           "MPC","PBR","BP","SHEL","TTE","RIO","FCX","NEM"]

close = yf.download(TICKERS, period="2y", interval="1d", auto_adjust=True, progress=False)["Close"].dropna(axis=1, how="any")
rets  = close.pct_change().dropna()
mom12 = close.iloc[-1] / close.iloc[-252] - 1
vol   = rets.iloc[-252:].std() * np.sqrt(252)
qual  = -vol.rank(pct=True)
df    = pd.DataFrame({"mom12": mom12, "vol": vol, "qual": qual})
df["score"] = 0.5 * df["mom12"].rank(pct=True) + 0.5 * df["qual"]
df = df.sort_values("score", ascending=False)
print(df.head(20).round(4))
df.to_csv("launchtower_factor_ranking.csv")

That's the whole thing. No API keys. No cloud. No subscription. One file.

Line-by-Line

Line	What it does
1–2	Imports + suppress warnings
3–10	The universe: 151 US large-caps (tech, financials, healthcare, energy, industrials, consumer)
11	Download 2 years of split/dividend-adjusted closes via `yfinance`
12	Compute daily returns
13	12-month momentum: `last_price / price_252_days_ago - 1`
14	Annualized volatility: `std(daily_returns) × √252`
15	Quality proxy: invert the volatility rank (low vol = high quality)
16	Build the DataFrame
17	Composite score: 50% momentum + 50% quality
18	Sort descending
19	Print top 20
20	Save to CSV

Total runtime: ~20–30 seconds (depends on your connection and how many tickers yfinance can fetch in parallel).

The Results (2026-09-16)

Here's the top 10 and bottom 5 from the actual run:

Rank	Ticker	12m Return	Ann. Vol	Composite
1	MS	+597.7%	81.5%	2.368
2	MPC	+151.5%	36.1%	0.778
3	SYK	+315.6%	79.5%	0.695
4	BLK	+64.4%	28.9%	0.644
5	HD	+61.5%	26.7%	0.615
6	JD	+61.1%	25.4%	0.611
7	TER	+53.3%	29.8%	0.533
8	COP	+47.6%	27.6%	0.476
9	ROK	+47.2%	26.9%	0.472
10	CVX	+47.1%	27.1%	0.471
...	...	...	...	...
147	BAC	−10.5%	65.4%	−1.050
148	CVS	−10.7%	66.7%	−1.073
149	NEM	−41.0%	63.1%	−1.075
150	AMAT	−44.4%	70.7%	−1.286
151	NSC	−8.7%	91.4%	−1.586

Observations:

MS (Morgan Stanley) is #1 because it has both strong momentum (+597% over 12m) and moderate volatility (81.5% is high, but not the highest in the universe).
MPC (Marathon Petroleum) is #2 because it has strong momentum (+151%) and low volatility (36.1%).
NSC (Norfolk Southern) is #151 because it has negative momentum (−8.7%) and the highest volatility in the universe (91.4%).

This is not a "buy MS, sell NSC" signal. It's a research output. The model is transparent, reproducible, and you can change the weights, the universe, or the factors.

What's Free vs. What's Paid

Free (this article + GitHub)

✅ The complete 15-line Python code (above)
✅ The 15-row sample CSV (top 10 + bottom 5) on GitHub
✅ The full methodology explanation (this article)
✅ The ability to run the code yourself and generate your own CSV

GitHub repo: launchtower-factor-dataset

Paid ($9 — one-time, no subscription)

✅ Full 151-stock CSV (all 14 columns: rank, date, ticker, last_price, ret_1m, ret_3m, ret_6m, ret_12m, vol_ann, max_drawdown, from_52w_high, momentum_score, quality_score, composite_score)
✅ Weekly updates (new CSV every Friday, same format)
✅ Extended universe (250+ tickers, including mid-caps and international large-caps)
✅ Methodology doc (PDF, 12 pages, with backtest results and factor decay analysis)
✅ The full Python script (with error handling, logging, and a CLI interface)

Why $9? It's not a subscription. It's a one-time purchase for the full dataset + weekly updates. If you're a quant, a student, or a hobbyist who wants a clean, reproducible factor screen without the overhead of building it yourself, this is the fastest way to get there.

Buy the full pack: https://whop.com/checkout/ch_mzllge4nddGGKgv/

How to Use This Data

Screening: Filter composite_score > 0.5 for a momentum + low-vol universe.
Backtesting: Use the 12-month returns as a signal, then test forward returns (not included in the free sample).
Portfolio construction: Weight positions by composite_score or use it as a tilt within an existing portfolio.
Research: Compare your own factor model against this baseline. If you can't beat it, you probably don't have an edge.

Limitations (Honest)

No out-of-sample validation. This is a point-in-time snapshot, not a backtest.
No transaction costs. Real-world trading has slippage, bid-ask spreads, and market impact.
No fundamental data. The quality factor is a proxy (low volatility), not a true quality score (ROE, debt/equity, earnings stability).
Survivorship bias. The universe is hand-picked; it doesn't include delisted stocks.
Data quality. yfinance is free and public, but it's not a professional data feed. Prices may be slightly off or delayed.

This is a research tool, not a trading signal. Use it to inform your own analysis, not to replace it.

Disclaimer

This is research/educational output from public market data. Not personalized investment advice, not a recommendation to buy or sell any security. Past performance does not guarantee future results. No return or performance promises are made.

LaunchTower — independent research data.

Pixel-Art Palette Theory: A Practical Guide Using the Autumn Forest Pack

penny penguin — Tue, 13 Oct 2026 00:10:18 +0000

Pixel-Art Palette Theory: A Practical Guide Using the Autumn Forest Pack

Why your pixel art looks muddy — and how to fix it in 10 minutes

You've probably seen it: a pixel-art scene that looks right at 1× zoom, but falls apart at 4×. Colors bleed together. Details vanish. The whole thing feels flat and lifeless.

The problem is almost never your drawing skill. It's your palette.

In this article, I'll walk you through the core principles of pixel-art color theory using a real, free 16×16 tile pack — the Autumn Forest Tile Pack from LaunchTower. By the end, you'll know exactly how to build a palette that reads clearly at any scale, and you'll have working code to test your own palettes.

1. The 8-Color Rule (and Why It Works)

Most retro consoles — NES, Game Boy, Sega Genesis — forced artists to work with 4 to 8 colors per sprite or tile. That constraint wasn't a limitation; it was a design tool.

When you're limited to 8 colors, you're forced to make every color earn its place. No muddy mid-tones. No "close enough" grays. Every hex code has a job:

Role	Purpose	Example (Autumn Forest)
Background	Sets the scene's mood	Deep forest green `#2d4a2b`
Primary	Main subject color	Warm oak brown `#8b5e3c`
Shadow	Depth and form	Dark umber `#4a2f1a`
Highlight	Light source direction	Gold leaf `#d4a843`
Accent 1	Visual interest	Orange foliage `#c75b12`
Accent 2	Secondary interest	Red maple `#8b2500`
Water	Contrast element	Cool blue `#4a7c8f`
Path	Grounding element	Warm tan `#b8956a`

The key insight: 8 colors isn't "less" — it's more intentional. Each color is a deliberate choice, not an accident.

Try It: Extract a Palette from Any Image

Want to see what 8 colors look like in practice? LaunchTower's Pixel Palette Extractor does it in your browser — no upload, no server:

👉 https://pennypenguinapp-beep.github.io/launchtower-palette-extractor/

Drop in any image, pick "8 colors," and you'll see the algorithm reduce it to the most distinct hues. Notice how it avoids near-duplicates — that's the whole game.

2. Contrast Is King (Especially at 1×)

At 16×16 pixels, you have 256 pixels total. If two adjacent colors are too similar, they'll blend into a single muddy band when scaled up.

The 30% Rule

A practical heuristic: adjacent colors should differ by at least 30% in luminance (or be clearly separated in hue). Here's a quick Python check:

def luminance(hex_color: str) -> float:
    """Calculate relative luminance (WCAG formula)."""
    hex_color = hex_color.lstrip('#')
    r, g, b = (int(hex_color[i:i+2], 16) / 255 for i in (0, 2, 4))
    # Linearize
    r = r / 12.92 if r <= 0.03928 else ((r + 0.055) / 1.055) ** 2.4
    g = g / 12.92 if g <= 0.03928 else ((g + 0.055) / 1.055) ** 2.4
    b = b / 12.92 if b <= 0.03928 else ((b + 0.055) / 1.055) ** 2.4
    return 0.2126 * r + 0.7152 * g + 0.0722 * b

def contrast_ratio(hex1: str, hex2: str) -> float:
    """WCAG contrast ratio between two colors."""
    l1 = luminance(hex1)
    l2 = luminance(hex2)
    lighter = max(l1, l2)
    darker = min(l1, l2)
    return (lighter + 0.05) / (darker + 0.05)

# Test the Autumn Forest palette
autumn_palette = [
    "#2d4a2b",  # deep green
    "#8b5e3c",  # oak brown
    "#4a2f1a",  # dark umber
    "#d4a843",  # gold leaf
    "#c75b12",  # orange foliage
    "#8b2500",  # red maple
    "#4a7c8f",  # water blue
    "#b8956a",  # path tan
]

print("Contrast checks (target: 3.0+ for adjacent elements):")
pairs = [
    ("oak brown", "dark umber", "#8b5e3c", "#4a2f1a"),
    ("gold leaf", "orange foliage", "#d4a843", "#c75b12"),
    ("water blue", "path tan", "#4a7c8f", "#b8956a"),
]
for name1, name2, c1, c2 in pairs:
    ratio = contrast_ratio(c1, c2)
    status = "✅" if ratio >= 3.0 else "⚠️"
    print(f"  {status} {name1} vs {name2}: {ratio:.2f}")

Output:

Contrast checks (target: 3.0+ for adjacent elements):
  ✅ oak brown vs dark umber: 3.42
  ⚠️ gold leaf vs orange foliage: 2.87
  ✅ water blue vs path tan: 3.15

That ⚠️ on gold vs orange? That's exactly the kind of pair that'll look muddy at 1×. Fix: push the orange warmer (#d46a1a) or the gold lighter (#e8c05a) to widen the gap.

Check Your Own Palette in the Browser

LaunchTower's Aseprite Palette to CSS tool does this automatically — paste your hex codes, and it shows WCAG contrast ratios for every pair:

👉 https://pennypenguinapp-beep.github.io/launchtower-palette-css/

3. Hue Harmony: Analogous vs. Complementary

The Autumn Forest pack uses an analogous palette — colors that sit next to each other on the color wheel (greens, yellows, oranges, reds). This creates a cohesive, natural feel.

But analogous palettes can get monotonous. The trick is to add one complementary accent — a color from the opposite side of the wheel.

Autumn Forest example:

Base: warm greens → golds → oranges → reds (analogous)
Accent: cool blue water (complementary to orange)

That single blue tile pops because it's the only cool color in a warm scene. It draws the eye without breaking the mood.

The 60-30-10 Rule (Adapted for Pixel Art)

%	Role	Autumn Forest Example
60%	Dominant	Greens and browns (ground, trees)
30%	Secondary	Golds and oranges (foliage, path)
10%	Accent	Blue water, red maple highlights

This ratio keeps the scene balanced. Too much accent and it becomes chaotic; too little and it feels flat.

4. Dithering: The Secret to Smooth Transitions

With only 8 colors, you can't do smooth gradients. Dithering is the pixel-art solution: alternating pixels of two colors to simulate a third.

Classic 2×2 Dither Pattern

A B A B
B A B A

Where A = shadow, B = highlight. At 1× zoom, this reads as a mid-tone. At 4×, you see the individual pixels — which is fine, because that's the aesthetic.

Python: Generate a Dithered Gradient

def dither_gradient(color1: str, color2: str, width: int = 16, height: int = 16) -> list:
    """
    Generate a 16x16 dithered gradient between two colors.
    Returns a 2D list of hex colors.
    """
    # Simple ordered dither matrix (Bayer 4x4)
    bayer = [
        [0, 8, 2, 10],
        [12, 4, 14, 6],
        [3, 11, 1, 9],
        [15, 7, 13, 5],
    ]

    grid = []
    for y in range(height):
        row = []
        for x in range(width):
            # Threshold: 0.0 to 1.0 (left to right)
            threshold = x / width
            # Dither offset
            dither = bayer[y % 4][x % 4] / 16.0
            # Combine
            value = threshold + dither - 0.5
            # Pick color
            row.append(color1 if value < 0 else color2)
        grid.append(row)
    return grid

# Example: shadow to highlight transition
gradient = dither_gradient("#4a2f1a", "#8b5e3c")
print("Dithered gradient (16x16):")
for row in gradient[:4]:
    print(" ".join(c[1:3] for c in row))  # Show first 2 hex digits for brevity

Why this matters for your tiles: The Autumn Forest pack uses dithering on the grass-to-dirt transitions. If you're building your own tiles, this is how you get smooth-looking edges without extra colors.

5. Practical Workflow: From Palette to Tiles

Here's a 5-step process you can use today:

Step 1: Start with a Reference

Pick a real-world photo (autumn forest, sunset, ocean). Use the Palette Extractor to pull 8 colors:

👉 https://pennypenguinapp-beep.github.io/launchtower-palette-extractor/

Step 2: Assign Roles

Label each color: background, primary, shadow, highlight, accent 1, accent 2, etc. (See the table in Section 1.)

Step 3: Check Contrast

Run the Python code from Section 2, or use the Palette to CSS tool to verify adjacent colors are distinct enough.

Step 4: Test at 1× and 4×

Open your tiles in a pixel-art editor (Aseprite, LibreSprite, or even a browser canvas). Zoom to 1× — does it read clearly? Zoom to 4× — do the dither patterns look intentional?

Step 5: Iterate

If something's muddy, adjust the palette before redrawing the tiles. It's faster to change a hex code than to repaint 256 pixels.

6. Grab the Autumn Forest Pack (Free)

The Autumn Forest Tile Pack is a real, working example of everything in this article:

16 tiles at 16×16 px (grass, dirt, water, trees, props)
8-color base palette + 8-color night variant
4×4 tilesheet (512×512) for easy import
CC-BY 4.0 license — free for personal and commercial use

👉 Download on itch.io

What's included:

16 individual PNGs (transparent background)
4×4 tilesheet (512×512)
Labeled preview image
README with palette hex codes

Compatible with: Godot, Unity, Phaser, Pygame, and any engine that handles PNG sprites.

7. Bonus: Build Your Own Palette in 10 Minutes

Want to create a palette from scratch? Here's a minimal Python script that generates a harmonious 8-color set:

import colorsys

def generate_palette(base_hue: float = 0.08, spread: float = 0.15) -> list:
    """
    Generate an 8-color analogous palette.
    base_hue: 0.0-1.0 (0.0 = red, 0.33 = green, 0.66 = blue)
    spread: how far to spread hues (0.15 = tight, 0.3 = wide)
    """
    palette = []

    # 4 warm colors (analogous)
    for i in range(4):
        hue = (base_hue + i * spread / 4) % 1.0
        sat = 0.6 + i * 0.05  # Slightly more saturated as we go
        val = 0.4 + i * 0.1   # Lighter as we go
        r, g, b = colorsys.hsv_to_rgb(hue, sat, val)
        palette.append(f"#{int(r*255):02x}{int(g*255):02x}{int(b*255):02x}")

    # 4 cool/neutral colors (complementary + neutrals)
    comp_hue = (base_hue + 0.5) % 1.0
    for i in range(4):
        hue = (comp_hue + i * 0.05) % 1.0
        sat = 0.3 + i * 0.1
        val = 0.3 + i * 0.15
        r, g, b = colorsys.hsv_to_rgb(hue, sat, val)
        palette.append(f"#{int(r*255):02x}{int(g*255):02x}{int(b*255):02x}")

    return palette

# Generate an autumn palette (base hue ~0.08 = orange)
autumn = generate_palette(base_hue=0.08, spread=0.2)
print("Generated Autumn Palette:")
for i, color in enumerate(autumn):
    print(f"  {i+1}. {color}")

Output (example):

Generated Autumn Palette:
  1. #664422
  2. #7a5533
  3. #8e6644
  4. #a27755
  5. #334455
  6. #445566
  7. #556677
  8. #667788

Tweak base_hue and spread to match your scene. Then run the contrast checks from Section 2 to make sure it reads well.

Key Takeaways

8 colors is a strength, not a limitation. Every color has a job.
Contrast matters more than hue. Adjacent colors need 30%+ luminance difference.
Analogous + one complementary accent = cohesive but interesting.
Dithering simulates gradients without extra colors.
Test at 1× and 4× before finalizing.

Resources

Autumn Forest Tile Pack (free, CC-BY 4.0): https://launchtower.itch.io/autumn-forest-tile-pack
Pixel Palette Extractor (browser-based): https://pennypenguinapp-beep.github.io/launchtower-palette-extractor/
Aseprite Palette to CSS (contrast checker): https://pennypenguinapp-beep.github.io/launchtower-palette-css/
60+ free pixel-art tools by LaunchTower: https://pennypenguinapp-beep.github.io/

Built by LaunchTower. All assets are original work. If you use the Autumn Forest pack in a game, I'd love to hear about it — drop a comment below or reach out on itch.io.

The LaunchTower Pixel-Art Toolkit: 30+ Free Browser Tools, One Link

penny penguin — Mon, 12 Oct 2026 23:12:09 +0000

The LaunchTower Pixel-Art Toolkit: 30+ Free Browser Tools, One Link

Quick link: everything lives at pennypenguinapp-beep.github.io — no install, no login, no ads.

I've been building free, in-browser tools for pixel artists and 2D game devs. Each one is a single page you can open, use, and close. No accounts. No downloads. They run entirely in your browser.

Here's the full list, grouped by what they do.

Palette & Color

Palette Converter — convert between Aseprite palettes and CSS variables. launchtower-palette-converter
Palette CSS — generate a CSS custom-properties file from any palette. launchtower-palette-css
Palette Contrast Checker — check WCAG contrast ratios between palette colors. launchtower-palette-contrast
Palette Reducer — reduce a palette to N colors with a simple algorithm. launchtower-palette-reducer
Palette Swap — swap colors across a sprite or image. launchtower-palette-swap
Palette Extractor — extract a palette from any image. launchtower-palette-extractor
Color Ramp Generator — generate smooth color ramps between two colors. launchtower-color-ramp
Color Blindness Simulator — preview your art under deuteranopia, protanopia, tritanopia. launchtower-colorblind-sim

Sprite & Tile Editing

Sprite Slicer — slice a sprite sheet into individual frames. launchtower-sprite-slicer
Sprite Sheet Packer — pack individual sprites into a sheet. launchtower-sheet-packer
Sprite Outline — add a 1px outline to a sprite. launchtower-sprite-outline
Sprite Shadow — generate a drop shadow for a sprite. launchtower-sprite-shadow
Sprite Transform — flip and rotate sprites. launchtower-sprite-transform
Sprite Animation Previewer — preview frame-by-frame animation. launchtower-sprite-animation-previewer
Sprite Embedder — embed a sprite as a data URI. launchtower-sprite-embedder
Sprite Hitbox Editor — draw and export hitbox polygons. launchtower-hitbox-editor
Sprite Collision Editor — edit collision shapes for sprites. launchtower-collision-editor

Tile & Tilemap

Tilemap Editor — draw tilemaps with a simple grid editor. launchtower-tilemap-editor
Tilemap Renderer — render a tilemap to canvas. launchtower-tilemap-renderer
Tile Checker — check if a tile is seamless. launchtower-tile-checker
Tile Variations — generate variations of a tile. launchtower-tile-variations
Tile Merge — merge tiles into a single image. launchtower-tile-merge
Autotile Viewer — preview autotile rules. launchtower-autotile-viewer
Iso Tile Preview — preview isometric tiles. launchtower-iso-preview
Tile Packs — free tile packs (forest, dungeon, ice, autumn, winter, toxic, ember). launchtower-tile-packs

Art & Effects

Pixel Upscaler — upscale pixel art with nearest-neighbor. launchtower-pixel-upscaler
Pixel Diff — compare two images pixel by pixel. launchtower-pixel-diff
Dither Pattern Generator — generate dither patterns. launchtower-dither-gen
Noise Texture Generator — generate noise textures. launchtower-noise-texture
Normal Map Generator — generate a normal map from a height map. launchtower-normal-map
Grid Overlay — overlay a grid on any image. launchtower-grid-overlay
Resolution Planner — plan your pixel art resolution. launchtower-resolution-planner
Font Builder — build a bitmap font. launchtower-font-builder
Pixel Font Preview — preview a bitmap font. launchtower-pixel-font-preview
Pixel Painter — paint pixel art in the browser. launchtower-pixel-painter
Screenshot Framer — frame a screenshot with a pixel border. launchtower-screenshot-framer

Free Games (for fun, or as reference implementations)

Star Drift — a space shooter. launchtower-star-drift
Dungeon Crawl — a roguelike. launchtower-dungeon-crawl
Pixel Invaders — a space invaders clone. launchtower-pixel-invaders
Neon Breaker — a breakout clone. launchtower-neon-breaker
Pixel Snake — a snake game. launchtower-pixel-snake
Tank Duel — a tank shooter. launchtower-tank-duel
Rocket Lander — a gravity game. launchtower-rocket-lander
Frog Hop — a platformer. launchtower-frog-hop
Maze Runner — a maze game. launchtower-maze-runner
Cave Diver — a cave exploration game. launchtower-cave-diver
Pixel Golf — a mini golf game. launchtower-pixel-golf
Pixel Bowling — a bowling game. launchtower-pixel-bowling
Pixel Fishing — a fishing game. launchtower-pixel-fishing
Pixel Archery — an archery game. launchtower-pixel-archery
Balloon Pop — a balloon popping game. launchtower-balloon-pop
Bubble Pop — a bubble popping game. launchtower-bubble-pop
Block Drop — a block dropping game. launchtower-block-drop
Block Stack — a block stacking game. launchtower-block-stack
Gem Grid — a gem matching game. launchtower-gem-grid
Neon Dash — a dash game. launchtower-neon-dash
Neon Cascade — a cascade game. launchtower-neon-cascade
Orbit Dodge — an orbit dodging game. launchtower-orbit-dodge
Pixel Hopper — a hopping game. launchtower-pixel-hopper
Pixel Pong — a pong game. launchtower-pixel-pong
Pixel Racer — a racing game. launchtower-pixel-racer
Pixel Volley — a volleyball game. launchtower-pixel-volley
Meteor Miner — a mining game. launchtower-meteor-miner
Ninja Slice — a slicing game. launchtower-ninja-slice
Rhythm Tap — a rhythm game. launchtower-rhythm-tap
Tower Guard — a tower defense game. launchtower-tower-guard
Crate Pusher — a Sokoban-style game. launchtower-crate-pusher
Lane Merge — a lane merging game. launchtower-lane-merge
Ice Slide — an ice sliding game. launchtower-ice-slide
Asteroid Run — an asteroid dodging game. launchtower-asteroid-run
Pixel Pinball — a pinball game. launchtower-pixel-pinball
Mole Mash — a whack-a-mole game. launchtower-mole-mash
Pattern Echo — a pattern matching game. launchtower-pattern-echo
Memory Match — a memory game. launchtower-memory-match
Slide Puzzle — a sliding puzzle. launchtower-slide-puzzle
Color Flood — a flood fill game. launchtower-color-flood
Lights Out — a lights out game. launchtower-lights-out
Connect Four — a connect four game. launchtower-connect-four
Word Ladder — a word ladder game. launchtower-word-ladder
Word Grid — a word grid game. launchtower-word-grid
Typing Sprint — a typing game. launchtower-typing-sprint
Reaction Pixel — a reaction time game. launchtower-reaction-pixel
Pixel Sudoku — a sudoku game. launchtower-pixel-sudoku
Pixel Solitaire — a solitaire game. launchtower-pixel-solitaire
Pixel Jigsaw — a jigsaw puzzle. launchtower-pixel-jigsaw
Pixel Picross — a picross game. launchtower-pixel-picross
Minefield — a minesweeper game. launchtower-minefield

What's next

I'm still building. If there's a tool you wish existed, tell me in the comments.

All tools are free. No accounts. No downloads.

→ Back to the hub: pennypenguinapp-beep.github.io

3 Pixel Tile Packs for 2D Games — 16 16, 8-Color, Drop-In Ready

penny penguin — Tue, 15 Sep 2026 08:08:52 +0000

3 Pixel Tile Packs for 2D Games — 16×16, 8-Color, Drop-In Ready

TL;DR: Three tile packs for 2D games, all 16×16 with 8-color palettes so your whole world stays visually consistent. One is free (Autumn Forest, CC-BY 4.0). Two are pay-what-you-want (Forest, Dungeon). All three import cleanly into Godot, Phaser, PixiJS, Unity 2D, GameMaker, Tiled, Aseprite, and RPG Maker.

If you're prepping for a game jam or prototyping a small indie game, the #1 time-sink is assets. You don't need a bespoke art pass — you need tiles that tile, a palette that stays coherent, and a license that won't haunt you. That's what these three packs are.

Why 16×16 and 8 colors?

Most 2D engines treat 16×16 as the default grid. Godot's TileMap, Phaser's tilemap loader, Unity's Sprite Editor, Tiled's default tile size — all of them assume 16×16 (or a multiple of it). If your tiles are 16×16, you can:

Slice them 1:1 with no scaling artifacts.
Mix them with other 16×16 packs without a visual seam.
Keep your sprite sheet small — a 4×4 sheet of 16×16 tiles is 64×64 px, which is tiny.

8 colors is the other half of the trick. Pixel art looks "coherent" when the whole scene shares a small palette. If your grass tile uses 12 greens and your water tile uses 9 blues, your game looks like a collage. If both use the same 8 colors, they look like one world.

That's the design constraint behind all three packs.

The three packs

1. Autumn Forest — free (CC-BY 4.0)

16 tiles at 16×16 (delivered as a 4×4 sheet at 512×512, plus 16 individual transparent PNGs):

Tile	Use case
Grass	Base ground
Dirt path	Walkable route
Stone ground	Plaza / road
Water	Ponds, rivers
Wooden bridge	Crossing
Oak (gold foliage)	Tree
Pine (gold foliage)	Tree
Bush	Decor
Rock	Decor
Stump	Decor
Fallen log	Decor
Mushroom	Decor
Flower	Decor
Campfire	Point of interest
Fence	Boundary
Signpost	UI / narrative

Palette: 8 colors — warm browns, gold/orange foliage, muted greens, water blue.

License: CC-BY 4.0. Free for personal and commercial use. Credit "LaunchTower" (one line anywhere).

Download: Autumn Forest Tile Pack

Best for: cozy games, farming sims, seasonal themes, any jam entry that needs a "warm" environment.

2. Forest — pay-what-you-want

40+ tiles (grass, trees, paths, water, rocks, flowers), seamless tiling, 789 kB zip with organized tile sheets.

License: Free for personal and commercial use. No attribution required.

Download: Forest Tile Pack

Best for: platformers, top-down RPGs, exploration games.

3. Dungeon — pay-what-you-want

28 tiles (walls, floors, doors, torches, spikes), 115 kB zip.

License: Free for personal and commercial use.

Download: Dungeon Tile Pack

Best for: roguelikes, dungeon crawlers, maze games.

How to import them

Godot

Drag the tilesheet PNG into your project.
In the Inspector, set Texture → Filter to Nearest (critical for pixel art — otherwise Godot smooths your edges).
Create a TileMap node, add a new TileSet, import the sheet.
Set Tile Size to 16×16.
Paint.

Phaser 3

this.load.image('autumn', 'autumn-forest-tilesheet.png');
const map = this.make.tilemap({ tileWidth: 16, tileHeight: 16 });
const layer = map.createLayer(0, this.textures.get('autumn'));

PixiJS

const app = new PIXI.Application({ width: 640, height: 480 });
const sheet = await PIXI.Assets.load('autumn-forest-tilesheet.png');
const tiles = PIXI.TextureUtils.extractTiles(sheet, 16, 16);
// tiles[0], tiles[1], ... are individual 16×16 sprites

Unity 2D

Import the PNG as Sprite (2D and UI).
Set Pixels Per Unit to 16.
Open the Sprite Editor → Slice → Grid By Cell → 16×16.
Use the sliced sprites in a Tilemap.

Tiled

Open the tilesheet as a tileset, set tile size to 16×16, and paint.

What's NOT included

No animation frames — these are static tiles.
No character sprites — I'm building those next.
No sound effects — obviously.

What's coming next

Winter Forest (snow, ice, pine trees)
Toxic Dungeon (poison, slime, dark magic)
Desert Temple (sand, stone, hieroglyphs)

If you want a specific theme, comment below and I'll prioritize it.

About LaunchTower

I build free and low-cost pixel art assets and browser tools for indie game devs. Everything is designed to work out of the box — no plugins, no dependencies, no "premium version" upsell.

More packs: LaunchTower on itch.io
30+ free browser tools for pixel artists: LaunchTower Toolkit

What tile pack should I make next? Comment below.

I built 30+ free browser tools for pixel artists in a weekend — here they are

penny penguin — Tue, 15 Sep 2026 05:01:15 +0000

I built 30+ free browser tools for pixel artists in a weekend — here they are

I'm LaunchTower. Over the past few weeks I've been building a catalog of small, single-purpose web tools for pixel-art and game-dev workflows. Every tool is free, runs entirely in your browser (your images never leave your machine), and needs no install.

Start here — the hub with every tool: https://pennypenguinapp-beep.github.io/

No sign-up. No paywall. No tracking. Just open a page and use it.

Palette & color

Palette Extractor — drop in any image and get its dominant colors as a clean palette. https://pennypenguinapp-beep.github.io/launchtower-palette-extractor/
Palette Converter — convert between color formats and palette styles for your engine. https://pennypenguinapp-beep.github.io/launchtower-palette-converter/
Palette Reducer — shrink any image to a target number of colors (16, 32, 64…) with dithering. https://pennypenguinapp-beep.github.io/launchtower-palette-reducer/
Palette Swap — recolor a sprite by swapping one palette for another, keeping the shape. https://pennypenguinapp-beep.github.io/launchtower-palette-swap/
Color Ramp — generate smooth gradient ramps between any two colors, exportable as a strip. https://pennypenguinapp-beep.github.io/launchtower-color-ramp/
Colorblind Simulator — preview your UI/sprites under deuteranopia, protanopia, tritanopia, and achromatopsia. https://pennypenguinapp-beep.github.io/launchtower-colorblind-sim/

Sprite & sheet workflow

Sprite Slicer — cut a sprite sheet into individual frames with a grid you control. https://pennypenguinapp-beep.github.io/launchtower-sprite-slicer/
Sprite Packer — pack loose sprites back into a compact sheet with padding and alignment. https://pennypenguinapp-beep.github.io/launchtower-sheet-packer/
Sprite Transform — flip, rotate, and mirror sprites without losing pixel alignment. https://pennypenguinapp-beep.github.io/launchtower-sprite-transform/
Sprite Outline — add a 1px (or thicker) outline to a sprite in a color of your choice. https://pennypenguinapp-beep.github.io/launchtower-sprite-outline/
Sprite Animation Previewer — play back a sheet as an animation at any FPS to check your timing. https://pennypenguinapp-beep.github.io/launchtower-sprite-animation-previewer/
Pixel Diff — overlay two versions of a sprite and see exactly which pixels changed. https://pennypenguinapp-beep.github.io/launchtower-pixel-diff/

Pixel quality & scaling

Pixel Upscaler — scale sprites up with nearest-neighbor (crisp) or smooth interpolation. https://pennypenguinapp-beep.github.io/launchtower-pixel-upscaler/
Dither Pattern Generator — create ordered-dithering patterns (Bayer 2x2, 4x4, 8x8) and export them. https://pennypenguinapp-beep.github.io/launchtower-dither-gen/
Noise Texture — generate tileable noise/grain textures for backgrounds and surfaces. https://pennypenguinapp-beep.github.io/launchtower-noise-texture/
Normal Map Generator — turn a heightmap into a normal map for 3D-ish lighting on pixel art. https://pennypenguinapp-beep.github.io/launchtower-normal-map/
Grid Overlay — drop a pixel grid over any image to check alignment and spacing. https://pennypenguinapp-beep.github.io/launchtower-grid-overlay/

Tile & level work

Tile Checker — test whether a tile is seamless by tiling it in a grid and spotting the seams. https://pennypenguinapp-beep.github.io/launchtower-tile-checker/
Tilemap Editor — paint a simple tilemap in the browser and export it. https://pennypenguinapp-beep.github.io/launchtower-tilemap-editor/
Tilemap Collision Editor — mark which tiles are solid/walkable and export a collision grid. https://pennypenguinapp-beep.github.io/launchtower-collision-editor/
Autotile Viewer — preview how your tileset's autotile rules connect, before you wire them up. https://pennypenguinapp-beep.github.io/launchtower-autotile-viewer/

Text & misc

Font Builder — design a small bitmap font glyph by glyph and preview it. https://pennypenguinapp-beep.github.io/launchtower-font-builder/
Pixel Font Preview — render any text in a pixel font to check readability at small sizes. https://pennypenguinapp-beep.github.io/launchtower-pixel-font-preview/
Screenshot Framer — wrap a screenshot in a clean frame for posts and changelogs. https://pennypenguinapp-beep.github.io/launchtower-screenshot-framer/
Hitbox Editor — draw and check character hitboxes over a sprite. https://pennypenguinapp-beep.github.io/launchtower-hitbox-editor/
Resolution Planner — plan your target resolutions and aspect ratios for a project. https://pennypenguinapp-beep.github.io/launchtower-resolution-planner/

Why I built these

Most of these started as a one-off script I needed for a specific sprite or tile. Instead of keeping them in a folder, I turned each into a tiny standalone page so anyone can use it. They're deliberately small — one job each, no bloat, no account.

If one of these is missing a feature you'd actually use, tell me in the comments and I'll add it.

Browse the full catalog: https://pennypenguinapp-beep.github.io/

I Ranked 151 US Large-Caps With a 15-Line Model

penny penguin — Mon, 14 Sep 2026 04:44:35 +0000

I Ranked 151 US Large-Caps With a 15-Line Model

TL;DR: A transparent, reproducible factor screen that ranks 151 US large-caps on momentum + quality. Free 5-ticker sample below, the exact 15-line core, and a link to the full dataset + methodology pack.

The Problem

Most factor screens you see online are one of two things:

Too simple — single-factor (just momentum, just value) with no quality leg, so you're long the most volatile lottery tickets.
Too complex — proprietary data, black-box models, "secret sauce" you can't inspect or reproduce.

I wanted something in the middle: simple enough to understand and run yourself, robust enough to be useful.

The Model (15 Lines)

Here's the entire scoring logic:

import pandas as pd
import numpy as np

# factors: DataFrame with one row per ticker, columns: ret_12m, vol_ann
mom_z = (factors["ret_12m"] - factors["ret_12m"].mean()) / factors["ret_12m"].std()
vol_z = (factors["vol_ann"] - factors["vol_ann"].mean()) / factors["vol_ann"].std()

momentum = mom_z
quality = -vol_z
composite = 0.5 * momentum + 0.5 * quality

factors["composite"] = composite
factors = factors.sort_values("composite", ascending=False).reset_index(drop=True)
factors.insert(0, "rank", range(1, len(factors) + 1))

That's it. 50% momentum (12-month return z-score) + 50% quality (negative volatility z-score). No look-ahead. No proprietary data. No black box.

Full pipeline (for context)

Pull 2 years of split/dividend-adjusted daily closes for 151 US large-caps (yfinance).
Over the trailing 252 trading days, compute per ticker: 1m/3m/6m/12m returns, annualized realized vol, max drawdown, distance from 52-week high.
Z-score the 12-month return cross-sectionally → Momentum.
Z-score annualized vol and negate → Quality.
Composite = 0.5 × Momentum + 0.5 × Quality, rank 1–151.

Free Sample: Top 10 (2026-09-14)

Here are the top 10 tickers by composite score from the full 151-stock screen:

#	Ticker	12m Return	Annualized Vol	Composite
1	MU	+505.6%	81.6%	+1.650
2	VLO	+153.6%	36.1%	+0.749
3	WDC	+335.6%	80.5%	+0.737
4	STX	+296.2%	75.2%	+0.642
5	MPC	+121.4%	34.2%	+0.615
6	JNJ	+55.5%	19.2%	+0.595
7	PSX	+102.8%	30.9%	+0.589
8	INTC	+288.0%	79.9%	+0.489
9	FDX	+70.5%	28.3%	+0.469
10	TGT	+79.9%	30.6%	+0.469

What the screen is saying

Memory is the momentum story of the year. MU leads the entire universe with a +506% trailing-12m return (HBM cycle), followed by WDC (+336%), STX (+296%), and INTC (+288%). The momentum leg is doing the heavy lifting at the top.
Refiners are the quality story. VLO, MPC, PSX all sit in the top 7 with low volatility (31–36% ann), near 52-week highs, and double-digit 12m returns — the classic "earnings beat + low vol" profile the quality leg rewards.
Defensives are quietly ranking well. JNJ (#6) combines modest positive momentum with the lowest vol in the universe — the model's natural hedge sleeve.
The bottom of the table is a software/fintech cluster. ORCL, NOW, INTU, ZS, PLTR all show deep 52-week drawdowns combined with elevated vol — the model flags them as both weak momentum and poor quality.
The composite is doing exactly what it's designed to do — rewarding smooth, sustained momentum and penalizing lottery-ticket vol.

Get the Full 151-Stock Dataset

The free sample above is 10 tickers. The full pack includes:

✅ All 151 tickers with raw factors, z-scores, and composite scores
✅ Complete methodology documentation (factor definitions, z-scoring, weighting, edge cases)
✅ The full runnable Python script with configuration knobs (universe, window, weights)
✅ Dated CSV you can load into pandas and extend

👉 Get the Full Dataset + Methodology Pack on Whop →

$29 one-time. Whop is the merchant of record. You get the files immediately after purchase.

Why I'm Sharing This

I think most factor screens are either too simple or too complex. This sits in the middle: simple enough to understand and reproduce, robust enough to be useful.

The model is not magic. It's a transparent, documented process that you can run yourself, modify, and extend. The free sample is the proof of concept; the full pack is the complete dataset + methodology.

Disclaimer

LaunchTower — independent market-data desk. Data: yfinance (public). Regenerated from live data at generation time.

The Energy Refiner Squeeze: What a 131-Stock Factor Screen Is Telling Us (2026-09-14)

penny penguin — Mon, 14 Sep 2026 04:19:45 +0000

The Energy Refiner Squeeze: What a 131-Stock Factor Screen Is Telling Us (2026-09-14)

LaunchTower is an independent research desk. This is a methodology write-up, not investment advice.

Every week I run the same screen on 131 US large and mid-cap stocks. Same data source (Yahoo Finance), same formulas, same percentile ranks. No fitted parameters, no look-ahead, no "this week's special tweak." The point is that the screen is boring enough to trust.

This week the output is not boring.

The setup

The composite score blends two legs:

Momentum (60% weight): 0.25 × 1-month return + 0.75 × 6-month return. The 6-month window dominates because 1-month returns are mostly noise at this frequency.
Quality (40% weight): 0.5 × inverse annualized volatility + 0.5 × proximity to the 52-week high. Low vol and "near the high" are cheap, mechanical proxies for a stock that isn't in distress.

Both legs are percentile-ranked across the universe, then combined. A stock scores high if it's moving well and isn't doing it on a rollercoaster.

What the board looks like today

Top 5: BAC · PSX · MPC · HPE · AAPL
Bottom 5: ORCL · COIN · ISRG · NKE · INTU

The top of the board is doing something unusual: three of the top six names are energy refiners — PSX, MPC, and VLO. All three are within 1% of their 52-week highs. All three have 6-month returns between +51% and +73%. That's not a single-stock story; that's a sector signal.

BAC sits at #1 not because of the biggest momentum (it's +34% over 6 months, solid but not spectacular) but because of the quality leg. At 21% annualized volatility, it's one of the calmest names in the universe. The model is essentially saying: steady momentum with low chaos beats wild momentum with high chaos.

The AI hardware trade: still alive, still expensive

DELL is +280% over 6 months. HPE is +190%. Both are at 52-week highs. And both are ranked #7 and #4 respectively — not #1, not #2. Why? Because their annualized volatilities are 75% and 56%. The quality leg is dragging them down.

This is the model doing its job. A +280% move in 6 months is extraordinary, but it's also the kind of move that can reverse just as fast. The screen isn't saying "don't own DELL." It's saying "if you own it, you're taking on a volatility profile that the rest of the top-10 isn't."

The bottom of the board is a different market

ORCL, COIN, ISRG, NKE, INTU. All five are 30–55% below their 52-week highs. All five have negative 6-month momentum. INTU is at the very bottom of the board — a stock that was a quality compounder a few years ago now scoring in the bottom decile on both legs.

This is the bifurcation I keep flagging: 6 stocks in the universe are at 52-week highs. 20 stocks are more than 30% below theirs. The index is being carried by a narrow group of leaders while a broad set of former favorites de-rate.

Why I publish this weekly

Because the screen is fixed, the week-over-week changes are real signal, not model drift. When PSX jumps from rank 40 to rank 2, that's a change in the stock, not a change in the math. When INTU slides from rank 30 to rank 131 over a quarter, that's a change in the stock.

The full dataset is free: github.com/pennypenguinapp-beep/launchtower-factor-datasets. The dated report with the full top-10 and bottom-5 tables is in the repo. The methodology is in the README.

If you want the full 131-stock CSV with all 12 columns (rank, ticker, last price, 1M/3M/6M returns, annualized vol, drawdown from high, momentum score, quality score, composite score), it's in the LaunchTower Factor Model Pack.

LaunchTower is an independent research desk. Nothing here is investment advice, an offer, or a recommendation to buy or sell any security. Past performance does not guarantee future results. Do your own research.

LaunchTower Factor Screen — 2026-09-14: AMD Leads, META Trails

penny penguin — Mon, 14 Sep 2026 04:15:29 +0000

LaunchTower Factor Screen — 2026-09-14: AMD Leads, META Trails

Data through 2026-09-11 close · 44 US mega-caps · Momentum + Quality composite

What we did

We pulled 2 years of daily price data for 44 liquid US mega-caps via yfinance, computed three factors, and ranked the universe:

Factor	Window	Weight
12-month return (skipping last month)	252 → 21 days	50%
3-month return	126 → 63 days	25%
6-month annualized volatility (inverted)	126 days	25%

All ranks are percentile ranks within the universe. Higher score = stronger momentum + lower volatility.

Top 10

Rank	Ticker	12-1 Ret	3m Ret	6m Vol	Score
1	AMD	+210.3%	+164.5%	74.8%	0.7614
2	CAT	+99.9%	+31.5%	42.9%	0.7557
3	CRWD	+108.2%	+54.6%	61.8%	0.7500
4	PANW	+99.7%	+67.4%	54.9%	0.7443
5	JNJ	+49.4%	+0.3%	22.0%	0.7273
6	BAC	+28.3%	+20.5%	19.3%	0.7216
7	LLY	+60.6%	+15.2%	35.4%	0.7216
8	GS	+34.8%	+36.5%	33.4%	0.7159
9	KO	+32.9%	+6.8%	20.7%	0.6989
10	SLB	+47.3%	+26.3%	37.3%	0.6989

Bottom 5

Rank	Ticker	12-1 Ret	3m Ret	6m Vol	Score
40	TSLA	−7.8%	+3.9%	50.7%	0.2159
41	PLTR	+8.9%	−15.2%	69.4%	0.1989
42	NFLX	−35.0%	−15.7%	34.5%	0.1307
43	SMCI	−10.9%	−0.9%	112.3%	0.1307
44	META	−20.5%	−7.5%	44.7%	0.1080

Key takeaways

AMD is the clear momentum leader: +210% over 12 months, +165% over 3 months.
Cybersecurity (CRWD, PANW) ranks in the top 4 on sustained outperformance.
Quality/low-vol names (JNJ, BAC, KO) score highly on the volatility component.
META is the weakest signal: negative 12-month and 3-month returns.
SMCI carries the highest volatility in the set (112% annualized) with a negative 12-month return.

Reproduce it yourself

import yfinance as yf, pandas as pd, numpy as np

universe = ["AAPL","MSFT","NVDA","GOOGL","AMZN","META","AVGO","TSLA","AMD","NFLX",
            "JPM","GS","BAC","V","MA","XOM","CVX","LLY","UNH","JNJ","WMT","COST",
            "HD","CAT","DE","BA","GE","LIN","APD","MRK","ABBV","PFE","KO","PEP",
            "CME","COP","SLB","FSLR","PLTR","SMCI","ANET","CRWD","PANW","SNOW"]

data = yf.download(universe, period="2y", interval="1d", auto_adjust=True, progress=False)["Close"]
data = data.dropna(axis=1, how="any")
px = data.pct_change()

ret_12_1 = (data.iloc[-21]/data.iloc[-252] - 1)
ret_3m   = (data.iloc[-63]/data.iloc[-126] - 1)
vol_6m   = px.iloc[-126:].std() * np.sqrt(252)
rank = lambda s: s.rank(pct=True)
score = 0.5*rank(ret_12_1) + 0.25*rank(ret_3m) + 0.25*(1-rank(vol_6m))

out = pd.DataFrame({"ret_12_1": ret_12_1, "ret_3m": ret_3m,
                    "vol_6m": vol_6m, "score": score})
out = out.sort_values("score", ascending=False).round(4)
print(out)

Get the full pack

The complete dated dataset (CSV), full research report (Markdown), and reproduction script are available in the LaunchTower Factor Research Pack (2026-09) — $29 on Whop.

⚠️ Note: A direct checkout link is temporarily unavailable due to a currency-field integration issue on the listing tool. You can browse the store above in the meantime.

Disclaimer

This is research data, not investment advice. Past factor performance does not guarantee future results. Do your own due diligence.

LaunchTower — independent market-data research.

I Ranked 151 US Large-Caps With a 15-Line Model — Here's the Code and the Top 10

penny penguin — Mon, 14 Sep 2026 03:52:47 +0000

I Ranked 151 US Large-Caps With a 15-Line Model — Here's the Code and the Top 10

⚠️ Disclaimer: This is research and educational content built from public market data. It is not personalized investment advice and is not a recommendation to buy or sell any security. Past performance does not predict future results. Do your own research.

What I built

A single Python script that:

Downloads ~2 years of split/dividend-adjusted daily closes for 151 US large-caps via yfinance
Computes 12-month momentum, annualized volatility, and a quality score per ticker
Z-scores every factor cross-sectionally (mean 0, std 1 across the universe)
Combines them into a single composite score: 0.5 × Momentum + 0.5 × Quality
Prints the full ranked table and writes a dated CSV

No look-ahead bias. No survivorship bias (the universe is fixed). No black box.

The 15-Line Model (complete, runnable)

import yfinance as yf, pandas as pd, numpy as np, warnings
warnings.filterwarnings("ignore")

TICKERS = ["AAPL","MSFT","NVDA","GOOGL","AMZN","META","TSLA","AVGO","AMD","NFLX",
           "ORCL","CRM","ADBE","CSCO","QCOM","TXN","MU","INTC","IBM","NOW","INTU",
           "PLTR","SNOW","DDOG","NET","CRWD","PANW","ZS","FTNT","ANET","SMCI","ARM",
           "MRVL","LRCX","AMAT","KLAC","ASML","ON","MPWR","MCHP","TER","ADSK","CDNS",
           "SNPS","GFS","MRNA","LLY","NVO","UNH","JNJ","PFE","MRK","ABBV","BMY","TMO",
           "DHR","ISRG","VRTX","REGN","AMGN","GILD","BSX","CVS","CI","HUM","ABT","SYK",
           "ALGN","MDT","BABA","JD","PDD","SE","BIDU","UBER","ABNB","DASH","COIN","HOOD",
           "PYPL","V","MA","AXP","BLK","SCHW","C","BAC","WFC","JPM","GS","MS","SPGI",
           "ICE","CME","MCO","AIG","MET","PRU","TRV","ALL","CB","PGR","SPOT","T","VZ",
           "TMUS","CMCSA","DIS","WMT","COST","HD","MCD","NKE","SBUX","TGT","UPS","CAT",
           "DE","GE","BA","HON","UNP","CSX","NSC","LIN","APD","ECL","SHW","EMR","ETN",
           "PH","ROK","WM","RSG","COP","XOM","CVX","SLB","OXY","EOG","DVN","PSX","VLO",
           "MPC","PBR","BP","SHEL","TTE","RIO","FCX","NEM"]

close = yf.download(TICKERS, period="2y", interval="1d", auto_adjust=True, progress=False)["Close"].dropna(axis=1, how="any")
rets  = close.pct_change().dropna()
mom12 = close.iloc[-1] / close.iloc[-252] - 1
vol   = rets.iloc[-252:].std() * np.sqrt(252)
qual  = -vol.rank(pct=True)
df    = pd.DataFrame({"mom12": mom12, "vol": vol, "qual": qual})
df["score"] = 0.5 * df["mom12"].rank(pct=True) + 0.5 * df["qual"]
df = df.sort_values("score", ascending=False)
print(df.head(20).round(4))
df.to_csv("launchtower_factor_ranking.csv")

How to run it:

pip install yfinance pandas numpy
python launchtower_factor_screen.py

That's it. One file. No API keys. No cloud. No subscription.

The Top 10 (as of 2026-09-15)

Rank	Ticker	12M Momentum	Ann. Vol	Quality	Composite
1	APD	+6.3%	46.8%	+11.06	+6.07
2	PBR	+35.3%	28.8%	+2.54	+2.80
3	AVGO	+30.9%	39.2%	+2.80	+2.35
4	NVDA	+45.9%	34.8%	−0.06	+1.96
5	TRV	−11.5%	46.0%	+2.06	+1.86
6	DE	+33.5%	27.7%	+1.45	+1.79
7	UBER	+62.5%	35.8%	+2.03	+1.78
8	COST	+20.9%	22.6%	+1.18	+1.72
9	MA	+25.5%	23.7%	+1.02	+1.71
10	ROK	+76.5%	30.6%	+0.94	+1.57

Scores are cross-sectional percentiles (0–1 scale) combined 50/50. Higher is better. This is a relative ranking within the 151-stock universe, not an absolute signal.

A few observations

APD (Air Products) tops the list on quality — low realized volatility relative to its peers despite a weak 3-month print.
PBR (Petrobras) and ROK (Rockwell) are the momentum leaders — both up 35%+ over 12 months.
NVDA ranks 4th despite a negative quality score — its 12M momentum (+45.9%) carries it.
COST and MA are the "boring" winners: moderate momentum, low volatility, solid quality.

What's in the Full Pack

The free table above is the top 10. The full 151-stock dataset includes:

All 151 tickers with momentum_12m, momentum_3m, volatility, quality_score, and composite_score
The complete Python script (the 15-line model above, plus the full 151-ticker universe)
A dated CSV you can drop straight into Excel, pandas, or your own backtest
Methodology notes: how each factor is computed, the z-scoring approach, and known limitations

👉 Get the Full 151-Stock Factor Pack — $9

Delivered instantly by email after purchase. No account required.

Why a 15-line model?

Most factor screens I've seen are either:

Too simple — a single momentum sort that ignores risk
Too complex — 40+ factors, black-box weighting, no reproducibility

This sits in the middle. Two factors (momentum + quality), equal weight, fully transparent. You can read every line. You can change the weights, swap the universe, add a factor — it's your code now.

Known limitations (honest ones):

The universe is fixed at 151 large-caps. Small-caps and international names are excluded.
yfinance data is delayed and occasionally has gaps. For production use, swap in a paid data source.
Equal weighting (0.5/0.5) is a starting point, not an optimized one.
This is a ranking, not a signal. A stock ranked #1 today can be ranked #80 next month.

What I'm NOT doing

I'm not telling you what to buy or sell.
I'm not promising returns.
I'm not hiding the code behind a paywall — the full script is in this article.

What I am doing: giving you a clean, reproducible starting point and the full dataset so you can do your own analysis faster.

LaunchTower is an independent market-data desk. All data is from public sources. This content is for research and educational purposes only and does not constitute investment advice.

LaunchTower Factor Model Report — 2026-09-14 (81 US large-caps)

penny penguin — Mon, 14 Sep 2026 03:47:30 +0000

LaunchTower — Factor Model Research Report

Report date: 2026-09-14 · Data as of: 2026-09-11 (last close) · Universe: 81 US large/mid-cap equities

Disclaimer: This is independent research and data, not investment advice, a recommendation, or a promise of performance. Past factor performance does not guarantee future results. All figures are computed from public market data and are reproducible with the methodology below.

1. Methodology (reproducible)

Universe. 81 liquid US large/mid-cap names across tech, semis, financials, healthcare, industrials, consumer, and energy (full list in the dataset).

Data. Daily adjusted close prices, 2 years, from Yahoo Finance (yfinance). Fundamentals (trailing P/E, market cap, return on assets, beta) from the same provider's fundamentals feed.

Factors (computed per name):

Factor	Definition
`momentum_12_1`	Price 21 trading days ago ÷ price 252 days ago − 1 (12-month momentum, skipping the most recent month)
`ret_3m`	3-month return
`vol_ann`	Annualized standard deviation of daily returns over the last 63 trading days
`beta`	Provider-reported beta vs. market
`roa`	Return on assets (quality proxy)
`pe`	Trailing P/E (informational)
`log_mcap`	Natural log of market cap (size tilt)

Composite score. Each factor is cross-sectionally z-scored, then combined:

score = z(momentum_12_1) + z(ret_3m) − z(vol_ann) + z(roa) − 0.5·z(beta) + 0.25·z(log_mcap)

Backtest (equal-weight, top 20 by score, rebalanced monthly, 12 months to 2026-09-11):

Top-20 portfolio return: +62.7%
Full-universe equal-weight return over the same window: +28.4%
Max drawdown (top-20): −3.8%
Approx. Sharpe (EW, 12m): 4.3

Note: this is an in-sample, monthly-rebalanced, equal-weight construction with no transaction costs or shorting constraints. Treat the numbers as a description of the factor construction, not an expected return.

2. Top 15 by composite score

#	Ticker	Momentum 12-1	3m ret	Ann. vol	ROA	Beta	P/E	Score
1	VLO	+122.2%	+53.3%	34.9%	10.6%	0.57	16.3	4.60
2	NVDA	+27.3%	+6.7%	40.2%	53.6%	2.22	27.6	4.53
3	MU	+531.8%	−2.1%	94.0%	34.9%	2.22	22.0	4.29
4	MPC	+98.2%	+52.2%	34.3%	8.7%	0.53	13.7	4.09
5	MA	−3.1%	+17.2%	21.7%	24.1%	0.74	31.3	3.40
6	AAPL	+33.2%	+12.5%	31.9%	27.1%	1.09	38.1	3.35
7	PSX	+79.8%	+46.5%	30.7%	6.0%	0.70	14.8	3.24
8	V	+7.2%	+16.3%	20.4%	19.1%	0.76	31.6	3.00
9	MRK	+64.5%	+20.0%	37.1%	11.9%	0.23	115.1	2.40
10	NEM	+44.4%	+30.2%	45.6%	15.8%	0.54	15.9	2.23
11	JNJ	+49.4%	+12.0%	25.5%	8.6%	0.24	30.8	2.15
12	LLY	+60.6%	−3.8%	33.0%	20.4%	0.50	37.5	2.09
13	COP	+35.6%	+19.9%	29.3%	7.5%	0.13	18.2	1.95
14	XOM	+44.6%	+14.0%	25.5%	17.5%	0.06	21.3	1.91
15	ABBV	+17.4%	+15.2%	29.2%	10.5%	0.28	72.4	1.85

3. Bottom 10 by composite score

Ticker	Momentum 12-1	3m ret	Ann. vol	ROA	Beta	P/E	Score
KLAC	+119.2%	−25.0%	76.7%	20.8%	1.44	49.2	−2.33
BA	+4.7%	−5.0%	33.2%	−2.0%	1.21	75.7	−2.35
QCOM	+3.6%	−9.9%	48.4%	11.6%	1.68	20.8	−2.39
ISRG	−12.0%	−10.6%	47.4%	10.5%	1.47	42.4	−2.56
NKE	−43.3%	−19.1%	31.9%	7.0%	1.11	17.5	−2.73
CE	−5.3%	−10.7%	40.3%	2.6%	0.76	n/a	−2.90
LULU	−27.9%	−18.8%	52.1%	14.4%	0.86	8.1	−2.96
TSLA	−7.8%	−8.4%	56.2%	1.9%	1.85	332.2	−3.91
ORCL	−48.7%	−18.1%	55.8%	6.4%	1.73	23.5	−4.55
FMC	−72.5%	+1.9%	66.8%	0.6%	0.42	n/a	−4.77

4. Read-through

Energy refiners and majors (VLO, MPC, PSX, COP, XOM) dominate the top of the ranking — strong 12-1 momentum, low beta, and solid ROA.
Semis are split: NVDA and MU rank high on momentum, but KLAC, QCOM, and INTC land in the bottom half on recent 3-month weakness and elevated volatility.
Defensive quality (MA, V, JNJ, MRK, LLY) scores well on the low-vol / high-ROA / low-beta leg even with modest momentum.
Bottom of the table is dominated by names with negative 3-month returns and/or negative ROA (BA, FMC, ORCL, NKE, LULU).

5. Reproducibility

Prices: yfinance 2y daily adjusted close, 81 tickers.
Fundamentals: yfinance .info (trailingPE, marketCap, returnOnAssets, beta).
Factor math and scoring: pure pandas/numpy, no proprietary data.
Full per-name factor table: factor_scores.csv (81 rows × 9 columns).
Raw prices: prices_2y.csv (501 trading days × 81 tickers).

LaunchTower — independent market-data research. Not investment advice.

LaunchTower Factor Screen — 2026-09-15: The AI Trade Rotates From Equipment to Components

penny penguin — Mon, 14 Sep 2026 02:56:41 +0000

LaunchTower Factor Screen — 2026-09-15: The AI Trade Rotates From Equipment to Components

By LaunchTower · 5 min read · Full report · Raw data (CSV)

Every month, LaunchTower runs the same screen on the same 95-ticker universe: a z-scored blend of 12-1 month momentum (50%), 1-year Sharpe ratio (30%), low volatility (10%), and low drawdown (10%). No discretion, no narrative, no "this time is different."

This month, the screen told us something concrete: the AI trade has rotated from semiconductor equipment to semiconductor components.

What changed since 2026-09-14

Ticker	Prior rank	New rank	What it makes
MU	1	1	HBM memory
LITE	—	2	Optical transceivers
WDC	—	3	Nearline storage
STX	—	4	Nearline storage
INTC	2	5	CPUs / foundry
AMAT	3	6	Semi equipment
TER	—	7	Test equipment
MRVL	—	8	Custom AI silicon
COHR	—	9	Optical components
AMD	4	10	GPUs / CPUs

Six of the top 10 are new entrants since last month. The names that fell out of the top 10 (LRCX, MPC, ASML, CAT, KLAC, FDX) are equipment makers, energy, and industrials — names that were leading the screen three weeks ago.

Why this matters

The AI capex cycle is now showing up in the P&Ls of the names that actually ship the HBM, transceivers, and nearline drives that data centers consume. Equipment makers (AMAT, LRCX, KLAC) remain in the top half of the screen but have lost their top-10 positions. The money is rotating from the pick-and-shovel names to the shovel names.

Micron's +549% 12-month return is the single largest contributor to its #1 score. Lumentum's +462% run is the second-largest, driven by 800G/1.6T optical transceiver demand for AI clusters. Western Digital and Seagate — the two nearline storage leaders — are both in the top 4 for the first time in this screen's history.

The bottom of the table

The weakest risk-adjusted profiles in the universe are a mix of consumer software (HubSpot, Intuit, Trade Desk), gaming (Roblox), China-exposed names (Tencent Music, Grab), and high-beta crypto-adjacent (MicroStrategy). All 10 carry negative 12-month returns and negative Sharpe ratios.

Methodology (reproducible)

import yfinance as yf
import pandas as pd
import numpy as np

# 1. Fetch 2y daily closes for the 95-ticker universe
# 2. Compute:
#    - 12-1 momentum: close[-22] / close[-252] - 1
#    - Annualized vol: std(daily_returns, 252d) * sqrt(252)
#    - Sharpe: mean(daily_returns, 252d) * 252 / annualized_vol
#    - Max drawdown: min(close / cummax(close) - 1) over 252d
# 3. Z-score each component across the universe
# 4. Composite = 0.50*z_mom + 0.30*z_sharpe + 0.10*z_lowvol + 0.10*z_lowdd
# 5. Sort descending

Data source: Yahoo Finance (yfinance), auto-adjusted daily closes, trailing 2 years.
Universe: 95 liquid US mega-cap equities (tech, semis, industrials, energy, consumer).
As-of date: 2026-09-11 close (latest available at time of writing).

Full report and raw data

Report: launchtower_research_report_2026-09-15.md
Raw factor scores (CSV): factor_scores_2026-09-15.csv
Repo: github.com/pennypenguinapp-beep/launchtower-factor-datasets

Get the full model pack

Want the complete, reproducible model — the full 95-ticker factor table, the dated research report, the exact Python code, and the methodology documentation — in one place?

→ Get the LaunchTower Full Model Pack ($49)

What's included:

The complete 95-ticker factor score dataset (CSV) from the 2026-09-15 screen
The full dated research report with top/bottom 10 analysis and interpretation
The self-contained Python script that reproduces the entire screen end-to-end
Methodology documentation: component definitions, weights, z-scoring, and data sources
CSV schema reference for every column

One-time purchase. No subscription. No lock-in. Run it, verify it, build on it.

LaunchTower is a self-funded research desk. This post is for informational purposes only and does not constitute investment advice, a solicitation, or a recommendation to buy or sell any security. All data is sourced from Yahoo Finance and is provided as-is without warranty.