Solvers of X & Y Proudly Launches PathXY - a Python Robot Path Planner
Ontario FLL Champion Team 52777 Solvers of X & Y launches PathXY, an FLL robot path planner supporting Python in LEGO Education SPIKE App 3 and Pybricks. Built from four years of Python experience and years of mentoring younger teams, PathXY addresses two persistent FLL challenges: time-consuming trial-and-error path testing and the lack of accessible Python documentation. The project aims to improve testing efficiency, teach deeper programming concepts, and help teams spend more time on robot design, mission strategy, and innovation.
By SolversMind Robotics
Published August 12, 2026 | Updated August 12, 2026
Reviewed by SolversMind Robotics mentors
Why does Ontario FLL Champion Team 52777 Launch PathXY, a Python Robot Path Planner?
PathXY is a new FIRST LEGO League robot path planner created by Ontario FLL Champion Team 52777 Solvers of X & Y to help teams reduce time-consuming trial-and-error testing and make the transition from block coding to Python easier. Supporting both LEGO Education SPIKE App 3 Python and Pybricks, PathXY helps students estimate robot movement, build repeatable paths, and access reusable functions for gyro PID driving, speed control, turning, and gyro reset. The idea grew from years of competition and mentoring younger FLL teams, where students repeatedly faced two challenges: guessing distances and turning angles through repeated testing, and finding limited FLL-specific Python documentation. Rather than providing only a quick solution, PathXY is designed to improve testing efficiency so teams can spend more time on robot design, mission strategy, iteration, and deeper learning while developing programming skills that extend beyond FIRST LEGO League.
PathXY Started With a Problem We Had Been Experiencing for Years
PathXY did not begin as an idea to simply create another FLL tool.
https://spike.solversmind.app/
It came from a problem we had experienced ourselves for years and continued to see when teaching and mentoring younger FIRST LEGO League teams.
When students begin developing an autonomous FLL mission, one of the first questions is often surprisingly simple:
How far should the robot drive, and how many degrees should it turn?
Without a visual path planning tool, the normal process often becomes:
guess a distance, run the robot, measure the error, change the number, run it again, adjust the turning angle, run it again, and repeat.
Sometimes this happens dozens of times for a single mission.
For experienced teams, this process is familiar. For newer teams, it can become frustrating very quickly.
And as coaches and mentors, we noticed something important.
A significant portion of students’ limited practice time was being consumed not by learning new engineering ideas, improving mechanisms, or exploring better mission strategies, but simply by repeatedly guessing numbers.
That became the first problem PathXY was designed to address.
Problem #1: Too Much FLL Practice Time Is Spent Guessing Distances and Angles
Testing is an essential part of engineering. We do not want to eliminate testing.
The problem is inefficient testing.
If students have no reasonable starting estimate for a robot path, much of their testing becomes trial and error rather than meaningful engineering iteration.
For example, a team may know that its robot needs to:
leave home
travel toward a mission model
turn approximately 40 to 50 degrees
approach the model
activate an attachment
turn again
return home
But translating that visual route into robot movement commands can require many rounds of guessing.
How many millimetres should the robot drive?
Is the turn 42 degrees or 48 degrees?
Where should the robot begin slowing down?
How should the next segment connect with the previous one?
The challenge becomes even greater when teams have multiple missions to complete within a limited competition season.
Solvers of X & Y began thinking about whether we could make that first stage of path development faster.
Not perfectly automatic.
Not a replacement for testing.
But a way to give teams a much better starting point.
That became one of the foundations of PathXY.
Improving Testing Efficiency, Not Eliminating Engineering
PathXY is not meant to remove testing from FIRST LEGO League.
Testing is where students learn.
Testing reveals mechanical problems, wheel slip, attachment interference, inconsistent field setup, acceleration issues, sensor drift, and many other real-world factors that cannot be completely predicted by software.
Instead, PathXY is designed to reduce the unproductive part of testing.
If students can begin with a reasonable estimate of distance, angle, and path geometry, they can spend less time asking:
“What number should we try next?”
and more time asking:
“Why did the robot behave this way, and how can we improve it?”
That difference matters.
Our goal is to improve the efficiency of the development cycle so teams have more time for:
robot mechanism design
mission strategy
attachment optimization
programming logic
debugging
sensor experimentation
reliability testing
performance analysis
iteration
Ultimately, PathXY is not about reducing the amount students learn.
It is about helping them spend more of their time on the parts of engineering that create the most learning.
Problem #2: Moving From Block Coding to Python Can Feel Like a Big Jump
The second challenge behind PathXY became increasingly clear as we worked with younger teams.
Many FIRST LEGO League students are very comfortable with block coding.
They understand loops.
They understand variables.
They understand motors and sensors.
They understand conditions.
They may already be solving fairly sophisticated robotics problems.
But when Python appears on the screen, many students suddenly feel that programming has become much harder.
The ideas may actually be familiar.
The presentation is different.
Instead of dragging blocks, students see:
functions, indentation, parameters, variables, syntax, libraries, sensor values, and text-based error messages.
For students who have never used a text programming language before, that transition can feel intimidating.
FLL-Specific Python Documentation Is Still Limited
Another issue is documentation.
There are excellent Python resources available online, but much of the general Python documentation is not written for a 10-, 11-, 12-, or 13-year-old student trying to make a LEGO SPIKE Prime robot accurately drive across an FLL competition mat.
Students may find documentation explaining Python syntax.
They may find examples for SPIKE Prime.
They may find Pybricks documentation.
But there is still a gap between learning basic Python and understanding how to build a reliable competitive FLL robot program.
Questions quickly become more specialized:
How do I keep my robot driving straight?
How do I use the yaw sensor?
What is PID?
How should I control speed?
Why does my robot overshoot?
How should I organize mission functions?
How do I make a reusable movement library?
How do I debug an inconsistent autonomous run?
These are exactly the questions our own students have spent years exploring.
That became the second major reason we decided to build PathXY.
Four Years of Python Experience Behind PathXY
Team 52777 Solvers of X & Y has been programming its LEGO SPIKE Prime competition robots with Python for approximately four years.
That experience did not come from simply reading documentation.
It came from thousands of real robot runs.
Competition.
Failure.
Debugging.
PID tuning.
Mechanical changes.
Sensor experiments.
Mission strategy revisions.
Changing attachments.
Different FLL mats.
Different field conditions.
And many, many hours of testing.
Over time, our students developed their own reusable programming structure and a deeper understanding of how software, hardware, sensors, and robot geometry work together.
PathXY represents an effort to take part of that experience and make it more accessible to other teams.
What Is PathXY?
PathXY is an FLL robot path planning and Python programming platform developed by Team 52777 Solvers of X & Y.
It is intended to help FIRST LEGO League teams plan robot movement more efficiently while learning the programming concepts behind accurate autonomous navigation.
PathXY supports:
LEGO Education SPIKE App 3 Python
Teams using the official LEGO Education environment can work with PathXY concepts and functions while staying within a familiar SPIKE Prime ecosystem.
Pybricks
Teams that want additional flexibility can also use PathXY with Pybricks and continue exploring more advanced Python-based robot programming.
This dual support is important to us because different teams are at different stages of their programming journey.
Some teams may be writing their first lines of Python.
Others may already be ready to build more advanced control systems.
PathXY is intended to help both groups continue moving forward.
What Is Included in PathXY Version 1?
PathXY Version 1 is deliberately focused on essential robot movement.
Once teams sign up, they will gain access to basic functions from our robot programming framework, including:
Move Forward With Gyro PID and Speed Control
The robot can move forward while continuously monitoring its heading through the SPIKE Prime motion sensor’s yaw measurement.
Rather than simply assuming that equal motor power will create a perfectly straight path, the robot can compare its desired heading with its actual heading and make corrections.
The function also incorporates speed control to create more controlled movement.
Move Backward With Gyro PID and Speed Control
The same principles can be applied while travelling backward.
This gives teams a reusable function for reverse movement while maintaining heading correction.
Turn Right
A reusable right-turn function provides a structured approach for creating directional changes within a mission path.
Turn Left
Teams can use the corresponding left-turn function to create repeatable turns in the opposite direction.
Gyro Reset
The gyro reset function allows teams to establish a known heading reference at appropriate points in their program.
These are fundamental functions, but they can form the basis of a large percentage of FLL autonomous navigation.
For many teams, these functions should provide a solid starting point for building reasonably accurate mission runs before moving into more advanced techniques.
Why We Use Gyro PID Instead of Only Motor Rotations
A robot does not operate in a perfect mathematical environment.
Two motors receiving the same command do not always behave identically.
Wheels wear.
Attachments change weight distribution.
Battery conditions vary.
The mat creates friction.
Robot construction introduces small differences.
As a result, simply asking both drive motors to rotate at the same speed does not guarantee that the robot will travel perfectly straight.
That is where feedback becomes important.
The SPIKE Prime motion sensor provides information about the robot’s orientation.
By reading the yaw value, the program can determine whether the robot has rotated away from its intended heading.
A PID-based controller can then calculate a correction.
If the robot begins drifting left, the motor outputs can be adjusted.
If it begins drifting right, the controller can respond in the opposite direction.
Instead of simply telling the robot what to do and hoping that it happens, the program continuously measures the robot’s behavior and reacts.
That is a fundamental concept in modern robotics:
closed-loop control.
PathXY Is Not Just a Quick Solution
It would be easy to describe PathXY as a tool that saves time.
But that is not our main goal.
PathXY is meant to help students improve the engineering development process.
If a path planner allows a team to establish its first robot route faster, that extra time can go somewhere much more valuable.
Students can rethink an attachment.
They can test a different mission combination.
They can reduce unnecessary robot movements.
They can optimize the order of missions.
They can improve reliability.
They can analyze why one strategy performs better than another.
They can attempt something more ambitious.
In other words, improving path planning efficiency can create more room for design and strategy iteration.
For us, that is the real value.
Solvers of X & Y Is More Than a Competition Team
Solvers of X & Y is proud to be an Ontario FIRST LEGO League Champion team, but competition results are only one part of what the team does.
Our students work throughout the year.
We do not stop developing when the FLL competition season ends.
Students continue exploring robotics, programming, engineering, research, artificial intelligence, emerging technologies, and new tools that may help solve real problems.
Some ideas eventually become competition solutions.
Others become technical experiments.
Some become outreach resources.
And some, like PathXY, begin as a problem inside our own team and grow into something that may help the broader community.
This year-round approach is important to SolversMind.
We want students to see robotics not only as a competition activity, but as a platform for continuously identifying problems, researching technologies, experimenting with solutions, and sharing what they learn.
Exploring Emerging Technologies, Including AI
Technology is changing quickly.
Artificial intelligence, machine learning, computer vision, robotics, simulation, data analysis, and automation are increasingly connected.
Python plays an important role across many of these areas.
For younger students, FLL can provide a surprisingly powerful introduction to this larger technology ecosystem.
A student who learns to:
read a sensor,
analyze an error,
write a function,
tune a control system,
debug a robot,
and interpret data
is already developing many of the thinking skills required for more advanced engineering and AI applications later.
That is one reason we believe the transition to Python is valuable.
The objective is not to use Python simply because it is more advanced than block coding.
The objective is to give students another tool they can grow with.
We Want to Transfer Knowledge, Not Keep It Inside Our Own Teams
SolversMind mentors multiple younger FLL teams, and knowledge transfer has always been an important part of our program.
Experienced students help younger students.
Older teams share what they have learned.
Students demonstrate techniques.
They explain mistakes.
They help others avoid problems they struggled with themselves.
But with PathXY, we want to take that idea further.
We do not want the knowledge developed by Solvers of X & Y to benefit only our own junior teams.
We want to share it with the broader FIRST LEGO League community.
There are students around Ontario, Canada, and the world facing many of the same challenges.
Some may not have an experienced Python mentor.
Some may have never seen PID control.
Some may want to move beyond blocks but do not know where to start.
Some may simply want a better way to develop robot paths.
If our students’ experience can help those teams move forward, we believe it should be shared.
“Teach a Person to Fish”
There is an old saying:
“Give a person a fish and you feed them for a day. Teach a person to fish and you feed them for a lifetime.”
That philosophy is central to PathXY.
Simply giving students a finished program may help them complete a mission.
But if they do not understand why it works, the learning opportunity is limited.
We want students to ask:
Why does the robot drift?
What does the gyro actually measure?
What is an error value?
How does proportional correction work?
What happens if the correction is too aggressive?
Why does speed affect accuracy?
How should a function be structured?
What can I change?
How can I improve it?
Those questions are far more important than simply getting a robot to a particular location.
A Comprehensive PathXY Python Curriculum Is Coming in September
Version 1 of PathXY provides the foundation.
But our next priority is education.
Solvers of X & Y is currently developing a comprehensive PathXY teaching curriculum, with the first release planned for mid-September 2026.
The curriculum will be designed to help students understand the fundamentals behind the code rather than simply copy functions.
Topics are expected to include:
transitioning from block coding to Python
Python syntax
variables
functions
parameters
loops
motor control
SPIKE Prime sensors
yaw and heading
gyro navigation
proportional control
PID fundamentals
speed control
turning
distance control
reusable robot functions
debugging
tuning
autonomous path planning
program organization
testing methodology
The goal is to create a learning path where students can begin with basic concepts and gradually understand more advanced robot control.
Version 1 Is Only the Beginning
The first release of PathXY focuses on core functions because we want teams to begin with a strong foundation.
At the same time, Solvers of X & Y is actively developing and refining more advanced features.
These functions require testing.
They need to work across different robot designs and different conditions.
They also need to be understandable.
That last requirement is important.
A sophisticated algorithm is not useful as an educational resource if students cannot learn from it.
As PathXY develops, we want to balance three goals:
accuracy, usability, and learning.
Additional PathXY functions will be released as they are refined.
Helping Teams Spend More Time on Strategy and Innovation
An FLL season gives students a limited amount of time.
Every hour matters.
If teams spend less time performing repetitive trial-and-error path setup, they can spend more time thinking creatively.
That might mean redesigning a mechanism.
It might mean combining two missions into one run.
It might mean attempting a mission they originally thought was too difficult.
It might mean studying robot consistency.
It might mean improving their Innovation Project.
It might simply mean having enough time to ask a deeper question.
That is what we hope PathXY enables.
It is not about making FIRST LEGO League easier.
It is about making the development process more productive so students can challenge themselves in more meaningful ways.
Applying the FIRST Innovation Mindset Beyond the Innovation Project
One of the most important lessons in FIRST LEGO League is learning to recognize a problem and develop a solution.
Students practice this through the Innovation Project every season.
But that mindset should not stop with the annual challenge topic.
A problem can exist anywhere.
We experienced a problem in robot development.
We watched younger teams experience the same problem.
We identified repeated pain points.
We asked whether technology could help.
Then our students began designing a solution.
That process itself reflects what FIRST teaches.
Identify. Research. Design. Prototype. Test. Iterate. Share.
PathXY is therefore more than a programming project.
It is also an example of students applying the FLL innovation process to improve the experience of other FLL teams.
We Hope PathXY Inspires Students to Build Their Own Solutions
Our biggest hope is not that every team uses PathXY exactly the way we use it.
Our hope is that students see what is possible.
Maybe a student uses PathXY and then modifies the code.
Maybe another team develops a better turning algorithm.
Maybe a student creates a visualization tool.
Maybe someone combines robot data with machine learning.
Maybe another team develops an entirely different path planner.
That would be a success.
FIRST LEGO League should not only teach students to solve the problems placed in front of them.
It should inspire them to notice problems that nobody has asked them to solve yet.
And then build something.
From FLL Python to Future Robotics and AI
For many students, FLL is their first serious experience with engineering.
They may begin with LEGO pieces.
Then block coding.
Then Python.
Later they may enter FTC or FRC.
They may begin working with Java, C++, CAD, computer vision, machine learning, electronics, mechanical design, simulation, or research.
PathXY is one small part of that journey.
But the thinking behind it can continue much further.
Understanding feedback.
Breaking large problems into functions.
Testing systematically.
Analyzing failure.
Using data.
Iterating.
Sharing knowledge.
These are not only FLL skills.
They are engineering skills.
Sharing What We Have Learned With the FLL Community
Solvers of X & Y has learned an enormous amount from FIRST.
We have learned from other teams.
From mentors.
From volunteers.
From competitions.
From failures.
From unexpected robot behavior.
From students younger than us asking surprisingly difficult questions.
PathXY is one way for our team to give some of that knowledge back.
We want our junior students to benefit from what we have learned.
But we also want students we may never meet to benefit.
That is what makes the FIRST community special.
Knowledge becomes more powerful when it is shared.
The Robot Is the Tool. The Student Is the Goal.
There is a saying within the FIRST community that strongly reflects how we think about PathXY:
“We don’t use kids to build robots. We use robots to build kids.”
The final robot matters.
Competition performance matters.
Accuracy matters.
Awards can be meaningful.
But they are not the ultimate outcome.
The real outcome is the student who learns to solve a difficult problem.
The student who is no longer afraid of Python.
The student who understands why a robot behaves differently than expected.
The student who tests an idea, fails, changes it, and tries again.
The student who develops something useful and decides to share it with someone else.
That is what we want PathXY to help create.
What Comes Next
PathXY Version 1 is the starting point.
Teams can begin exploring its fundamental movement functions in SPIKE App 3 Python and Pybricks, including gyro PID forward and backward driving, speed control, turning, and gyro reset.
Solvers of X & Y will continue refining advanced functions and expanding the PathXY platform.
Our comprehensive teaching curriculum is targeted for release in mid-September 2026.
Most importantly, we will continue learning.
Because PathXY is not meant to be a finished answer.
It is another problem-solving journey.
And we hope other FLL students will join us, learn from it, improve it, question it, and eventually create solutions of their own.
Tags:
PathXY, FIRST LEGO League, FLL, FLL Python, FLL Robot Path Planner, Solvers of X & Y, Team 52777, SPIKE Prime, SPIKE App 3, Pybricks, Python Robotics, Gyro PID, Robot Programming, SolversMind Robotics