Penguin Empire · Team 2551

From zero code to driving a robot.

The exact path every new Penguin Empire programmer takes — from your first line of Java to code running on the competition robot.

Start Lesson 1 → See the curriculum
IntakeSubsystem.java ▶ Run
public class IntakeSubsystem extends SubsystemBase {
private final CANSparkMax motor =
new CANSparkMax(9, MotorType.kBrushless);
 
public void runIntake(double speed) {
motor.set(speed);
}
}
Output
[WPILib] IntakeSubsystem registered.
[REV] CANSparkMax ID 9 — ready.
Robot enabled — Teleop.
Team 2551's robot on the field during a match
Where the code ends up
  • 19Units
  • 64Lessons, zero to robot
  • 2Phases · Java, then the robot
  • 0Installs to get started
  • LiveJava compiler in the page
  • 2551Penguin Empire Robotics
Both phases required

Two phases. Both required. One working robot.

You can't skip either phase — Phase 1 teaches you the language, Phase 2 puts it on the robot. Complete them in order and you'll have everything you need to program a real FRC robot from scratch.

{ } Phase 1 · Foundations

Java & Object-Oriented Programming

Variables, loops, methods, arrays, and the big one — classes & objects. Every concept runs live in your browser. Capped by the Alice's Kitchen project.

6units
33lessons
Livecompiler
Begin Phase 1 → 2551 Phase 2 · The Robot

FRC Robot Programming

Motors, encoders, PID, command-based structure, swerve drive, Limelight vision, and PathPlanner autonomous — built on real Team 2551 hardware.

13units
31lessons
WPILibverified
Preview Phase 2 →
Not a textbook

Built to be done, not just read.

Every lesson follows the same rhythm — read a little, then do something — so a concept sticks before the next one builds on it.

Live Java compiler

Write real Java. Run it on the page.

Every Phase 1 lesson has a compiler built right in. Type real Java, hit Run, and watch it execute — no installs, no setup. You see your code work long before you ever touch a robot.

  • Runs a real JDK, right in the browser
  • Edit the example and re-run it instantly
  • The same language the robot is programmed in
Greeting.java ▶ Run
String team = "Penguin Empire";
int number = 2551;
System.out.println(team + " " + number);
Output
Penguin Empire 2551
Hands-on challenges

Don't just read it — prove you've got it.

Fill-in-the-blank code, predict-the-output puzzles, and quick checkpoints with instant feedback. Each one has to click before the lesson moves on, so nothing gets quietly skipped.

  • Fill-in-the-blank & predict-the-output
  • Instant right/wrong feedback with hints
  • Reveal the worked solution when you're ready
Fill in the blankCheckpoint 3 / 4

Complete the line so it prints a greeting to the console:

System.out._______("Hello, 2551!");
println Check ✓
✓ Correct — println prints a line, then moves to the next.
Real-mechanism projects

Build the actual robot, one subsystem at a time.

Each unit ends with a buildable project tied to a real mechanism — an intake, a flywheel, an arm, the drivetrain. The code you write maps directly to hardware that goes on the field, with the team's war stories and pitfalls baked in.

  • Verified against WPILib, REV, CTRE & Limelight docs
  • Real Team 2551 CAN IDs and wiring
  • "The fried motor" war stories so you don't repeat them
Project · Intake Subsystem
Unit 7 · Structuring Behavior
Buildable
  • Create the IntakeSubsystem class
  • Wire the roller motor (CAN ID 21)
  • Add runIntake() / stop()
  • Bind it to the operator's right trigger

Plus everything you'd expect from a real course

War stories & pitfalls

The fried motor. The two-day voltage bug. We keep the team's hard-won lessons so you don't repeat them.

Verified WPILib syntax

Code samples are checked against the official WPILib, REV, CTRE and Limelight docs — not someone's memory.

Saved progress

Check off lessons as you finish. The site remembers where you are so you can pick up next meeting.

The journey

How a Penguin programmer is made

The order matters. You can't build autonomous until the mechanics and vision work — so we teach in the right sequence.

1

Learn to think in code

Java fundamentals — variables, logic, loops, and methods — all runnable in your browser.

2

Learn to think in objects

Classes, objects, encapsulation, and inheritance: the model the entire WPILib library is built on.

3

Meet the robot

RoboRIO, CAN bus, motors, the toolchain, and the project anatomy that everything hangs on.

4

Make it move & sense

Spin a motor, read an encoder, and tame it with PID closed-loop control.

5

Structure real behavior

Commands, subsystems, button bindings, swerve driving, and Limelight vision.

6

Run it yourself

PathPlanner autonomous and a game-day playbook. Now you can program the robot.

Questions

Frequently asked questions

New to the team or new to code? Start here.

Do I need any coding experience?
None at all. The academy starts at absolute zero — Phase 1 assumes you've never written a line of code and builds up step by step, from variables all the way to full object-oriented programming.
Do I have to install anything to start?
No. All of Phase 1 runs in your browser through an embedded Java compiler, so you can write and run real code with nothing installed. When you reach Phase 2, the course walks you through setting up the FRC toolchain (WPILib + VS Code) so you can deploy to a robot.
How long does it take?
It's self-paced. The course splits into Phase 1 (Java & OOP, 6 units) and Phase 2 (FRC robot programming, 13 units), and the site saves your progress automatically — so you can do a few lessons each meeting and pick up exactly where you left off.
Do I need a robot to learn?
No. You learn all of Java and most robot concepts without any hardware. The Phase 2 code samples are verified against the official WPILib, REV, CTRE, and Limelight docs, and each unit ends with a buildable project you can apply to a real subsystem when hardware is available.
What will I be able to do when I finish?
Program a competition FRC robot in Java from scratch — motors, encoders, PID, command-based structure, swerve drive, Limelight vision, and PathPlanner autonomous.
Is this only for Team 2551 members?
It's built as the programming onboarding path for Penguin Empire Robotics 2551, with our real hardware and conventions. But anyone learning to program an FRC robot in Java is welcome to follow along.

Ready? It starts with one line of code.

No setup, no installs, no experience. Open Lesson 1 and make the computer say hello.

Start learning now →