I Made an FPS Calculator Today

Today, I worked on a small but exciting project – creating an FPS (Frames Per Second) calculator. If you’re into gaming or graphics programming, you’ve probably heard the term "FPS" a lot. It measures how many frames are displayed per second in an application, and higher FPS means smoother visuals. My goal was to build a simple tool to calculate and display FPS in real-time.

How It Works

An FPS calculator works by measuring how many frames are rendered in a given period (usually one second). To achieve this, I used Python and a library called PyQt5, which makes building graphical user interfaces (GUIs) straightforward.

The program runs two timers:

1. One timer simulates frames being processed at a set interval (mimicking real-time rendering).

2. The other calculates how many frames were processed over the past second and updates the display.

When you run the program, it shows a small window with the current FPS. The interface is minimal—just a label that updates dynamically as the frames are counted. It’s like a little widget that tells you how fast your application is running.

import sys
from PyQt5.QtCore import QTimer
from PyQt5.QtWidgets import QApplication, QLabel, QVBoxLayout, QWidget

class FPSWidget(QWidget):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("FPS Calculator")
        self.resize(200, 100)
        self.layout = QVBoxLayout()
        self.fps_label = QLabel("FPS: Calculating...", self)
        self.fps_label.setStyleSheet("font-size: 16px;")
        self.layout.addWidget(self.fps_label)
        self.setLayout(self.layout)
        self.frame_count = 0
        self.last_time = 0
        self.timer = QTimer()
        self.timer.timeout.connect(self.update_fps)
        self.timer.start(1000 // 60) 

        self.fps_timer = QTimer()
        self.fps_timer.timeout.connect(self.calculate_fps)
        self.fps_timer.start(1000)

    def update_fps(self):
        self.frame_count += 1

    def calculate_fps(self):
        current_time = self.timer.remainingTime()
        fps = self.frame_count
        self.fps_label.setText(f"FPS: {fps}")
        self.frame_count = 0 

if __name__ == "__main__":
    app = QApplication(sys.argv)
    fps_widget = FPSWidget()
    fps_widget.show()
    sys.exit(app.exec_())

I’ve always been curious about how FPS is calculated in games and other software. Building this project gave me a deeper understanding of how frames are managed and how performance is monitored. It’s a great way to learn the basics of event-driven programming and timers.

• Work with timers to simulate real-time events.

• Calculate and display dynamic values in a GUI.

In the future, I’d like to improve the tool by adding more features, like a graph to show FPS trends or the ability to test an actual application. For now, I’m happy with how it turned out—it’s a small but satisfying achievement.

If you’re new to programming, I highly recommend trying out projects like this. Checkout our project called LiveAPI ; Super convenient API documentation in scale.