Build GUIs with
Perl

Why Build a GUI in Perl?

Perl has been a powerhouse scripting language for decades. While it's best known for text processing and system automation, its CPAN ecosystem ships robust bindings to virtually every major GUI framework — letting you wrap your existing Perl logic in a native-feeling desktop window without rewriting a single line of business logic.

This guide focuses on Tk (the most beginner-friendly option) and Wx (wxWidgets, for production-grade native-look apps), with brief notes on Prima, Gtk3, and the Windows-only Win32::GUI.

Choosing a Toolkit

Each toolkit has different trade-offs. Pick based on your target platform, desired look-and-feel, and how much C-level complexity you are comfortable setting up.

Installation

Perl/Tk

# Linux (Debian/Ubuntu)
sudo apt-get install perl-tk

# or via CPAN
cpan Tk

# Strawberry Perl on Windows
cpan Tk

Wx (wxWidgets)

# Linux — install system wxWidgets first
sudo apt-get install libwxgtk3.2-dev
cpan Wx

# Windows with Strawberry Perl
cpan Wx

Prima

cpan Prima

Tk Basics — Hello World

Every Tk program follows a three-step pattern: create the main window, add widgets, and enter the event loop.

#!/usr/bin/perl
use strict;
use warnings;
use Tk;               # import the Tk module

# 1. Create the main (root) window
my $mw = MainWindow->new();
$mw->title("Hello, Perl/Tk!");
$mw->geometry("300x120");   # width x height in pixels

# 2. Add a Label widget
$mw->Label(
    -text => "Hello, World!",
    -font => "Arial 18 bold",
)->pack();

# 3. Enter the event loop (never returns until window closes)
MainLoop();

Save as hello.pl and run with perl hello.pl. A window should appear with centred text.

Common Tk Widgets

Tk ships with everything you need for everyday GUIs. Below is a cheat-sheet of the widgets you'll use most often.

Layout Managers

Tk provides three geometry managers. You must use only one per container (mixing them causes errors).

pack — flow-based (simplest)

$btn1->pack(-side => 'left',  -padx => 5, -pady => 5);
$btn2->pack(-side => 'right', -padx => 5);
$label->pack(-side => 'top',  -fill => 'x', -expand => 1);
# -fill: 'x', 'y', 'both', 'none'   -expand: 1 to grow with window

grid — table-based (most flexible)

$label->grid(-row => 0, -column => 0, -sticky => 'w');
$entry->grid(-row => 0, -column => 1, -sticky => 'ew');
$btn->  grid(-row => 1, -column => 0, -columnspan => 2);
# -sticky: compass points 'n','s','e','w','nw','nsew' etc.

place — absolute positioning

$widget->place(-x => 50, -y => 80, -width => 120, -height => 30);
# Use sparingly — breaks on window resize

Events & Callbacks

User interaction is handled through callbacks (code references or anonymous subs) attached to widgets.

Button callback

sub greet {
    print "Hello!\n";
}

$mw->Button(
    -text    => "Say Hello",
    -command => \&greet,   # pass a code reference
)->pack();

# Or use an anonymous sub with closures over $mw
$mw->Button(
    -text    => "Quit",
    -command => sub { $mw->destroy() },
)->pack();

Binding arbitrary events

# Keyboard binding — Ctrl+Q quits
$mw->bind('<Control-q>' => sub { $mw->destroy() });

# Mouse hover on a canvas
$canvas->bind('<Enter>' => sub { print "Mouse entered!\n" });

# <Button-1> = left click  <Button-3> = right click
$widget->bind('<Button-1>' => \&on_click);

# Reading the event object
$widget->bind('<Motion>' => sub {
    my $ev = $widget->XEvent();
    printf "x=%d y=%d\n", $ev->x, $ev->y;
});

Reading widget values

my $name = "";
my $entry = $mw->Entry(-textvariable => \$name)->pack();

$mw->Button(
    -text    => "Greet",
    -command => sub {
        print "Hello, $name!\n";  # $name updates automatically
    },
)->pack();

Full Tk Application — Unit Converter

This example puts everything together: a Frame layout, Entry inputs, Labels, a drop-down via Optionmenu, and a button callback that processes the conversion.

#!/usr/bin/perl
use strict;
use warnings;
use Tk;

my $mw = MainWindow->new();
$mw->title("Unit Converter");
$mw->resizable(0, 0);   # lock width, height

# ── State variables ──────────────────────────────────────
my $input_val  = "";
my $result_var = "";
my $mode       = "Km → Miles";

my %conversions = (
    "Km → Miles"  => sub { $_[0] * 0.621371 },
    "Miles → Km"  => sub { $_[0] * 1.60934  },
    "°C → °F"     => sub { $_[0] * 9/5 + 32 },
    "°F → °C"     => sub { ($_[0] - 32) * 5/9 },
    "Kg → Lbs"    => sub { $_[0] * 2.20462  },
    "Lbs → Kg"    => sub { $_[0] * 0.453592 },
);

# ── Callback ──────────────────────────────────────────────
sub convert {
    unless ($input_val =~ /^\d+(\.\d+)?$/) {
        $result_var = "Invalid input";
        return;
    }
    my $fn     = $conversions{$mode};
    my $result = $fn->($input_val);
    $result_var = sprintf("%.4f", $result);
}

# ── UI ────────────────────────────────────────────────────
my $top = $mw->Frame(-padx => 20, -pady => 16)->pack(-fill => 'x');

$top->Label(-text => "Value:")->grid(-row=>0,-column=>0,-sticky=>'w');
$top->Entry(-textvariable => \$input_val, -width => 18)
    ->grid(-row=>0,-column=>1,-sticky=>'ew',-padx=>8);

$top->Label(-text => "Mode:")->grid(-row=>1,-column=>0,-sticky=>'w',-pady=>6);
$top->Optionmenu(
    -variable => \$mode,
    -options  => [sort keys %conversions],
)->grid(-row=>1,-column=>1,-sticky=>'ew',-padx=>8);

$top->Button(
    -text    => "Convert",
    -command => \&convert,
    -bg      => '#4a90d9',
    -fg      => 'white',
)->grid(-row=>2,-column=>0,-columnspan=>2,-pady=>10);

$top->Label(
    -text     => "Result:",
    -font     => "Arial 12",
)->grid(-row=>3,-column=>0,-sticky=>'w');

$top->Label(
    -textvariable => \$result_var,
    -font         => "Arial 14 bold",
    -fg           => '#2a7a40',
)->grid(-row=>3,-column=>1,-sticky=>'w');

MainLoop();

Wx — Native Look & Feel

The Wx module wraps the cross-platform wxWidgets C++ library. Controls look and behave identically to native OS widgets — menus, dialogs, and buttons all match the OS theme.

Structure of a Wx program

Wx uses an object-oriented design with three mandatory classes: App, Frame, and Panel. Events use an EVT_* macro system.

#!/usr/bin/perl
use strict;
use warnings;
use Wx qw(:everything);

# ── App class ────────────────────────────────────────────
package MyApp;
use parent -norequire, 'Wx::App';

sub OnInit {
    my ($self) = @_;
    my $frame = MyFrame->new();
    $frame->Show(1);
    return 1;
}

# ── Frame class ──────────────────────────────────────────
package MyFrame;
use parent -norequire, 'Wx::Frame';

sub new {
    my ($class) = @_;
    my $self = $class->SUPER::new(
        undef,           # parent (undef = top-level)
        -1,              # id  (-1 = auto)
        "Wx Hello",      # title
        wxDefaultPosition,
        [400, 200],       # size [w, h]
    );

    my $panel  = Wx::Panel->new($self, -1);
    my $button = Wx::Button->new($panel, -1, "Click Me",
                              wxDefaultPosition, wxDefaultSize);

    # Connect the button's click event to a method
    Wx::Event::EVT_BUTTON($self, $button, \&OnButton);

    return $self;
}

sub OnButton {
    my ($self, $event) = @_;
    Wx::MessageBox("You clicked the button!", "Hello",
                   wxOK | wxICON_INFORMATION, $self);
}

# ── Main ─────────────────────────────────────────────────
package main;
my $app = MyApp->new();
$app->MainLoop();

Full Wx App — Text Editor

A simple Wx text editor demonstrating menus, a toolbar feel, a TextCtrl for the editing area, and file dialogs.

#!/usr/bin/perl
use strict;
use warnings;
use Wx qw(:everything);
use Wx::Event qw(EVT_MENU);

# ── Constants for menu IDs ────────────────────────────────
use constant {
    ID_NEW   => 101,
    ID_OPEN  => 102,
    ID_SAVE  => 103,
    ID_ABOUT => 104,
};

package EditorApp;
use parent -norequire, 'Wx::App';
sub OnInit {
    my ($self) = @_;
    EditorFrame->new()->Show(1);
    return 1;
}

package EditorFrame;
use parent -norequire, 'Wx::Frame';

sub new {
    my ($class) = @_;
    my $self = $class->SUPER::new(undef, -1,
        "Perl Text Editor", wxDefaultPosition, [700, 500]);

    # Build the menu bar
    my $menubar = Wx::MenuBar->new();
    my $file    = Wx::Menu->new();
    $file->Append(ID_NEW,  "&New\tCtrl+N");
    $file->Append(ID_OPEN, "&Open\tCtrl+O");
    $file->Append(ID_SAVE, "&Save\tCtrl+S");
    $file->AppendSeparator();
    $file->Append(wxID_EXIT, "E&xit\tAlt+F4");
    $menubar->Append($file, "&File");
    $self->SetMenuBar($menubar);

    # Text area (TE_MULTILINE = multi-line, TE_RICH2 = rich text)
    $self->{editor} = Wx::TextCtrl->new(
        $self, -1, "",
        wxDefaultPosition, wxDefaultSize,
        wxTE_MULTILINE | wxTE_RICH2,
    );
    $self->{current_file} = undef;
    $self->CreateStatusBar();

    # Wire menu events
    EVT_MENU($self, ID_NEW,   \&OnNew);
    EVT_MENU($self, ID_OPEN,  \&OnOpen);
    EVT_MENU($self, ID_SAVE,  \&OnSave);
    EVT_MENU($self, wxID_EXIT, \&OnQuit);

    return $self;
}

sub OnNew  { $_[0]->{editor}->SetValue("") }
sub OnQuit { $_[0]->Destroy() }

sub OnOpen {
    my ($self) = @_;
    my $dialog = Wx::FileDialog->new(
        $self, "Open File", "", "",
        "Text files (*.txt)|*.txt|All files (*.*)|*.*",
        wxFD_OPEN | wxFD_FILE_MUST_EXIST,
    );
    if ($dialog->ShowModal() == wxID_OK) {
        my $path = $dialog->GetPath();
        open my $fh, '<', $path or die $!;
        local /;
        $self->{editor}->SetValue(<$fh>);
        close $fh;
        $self->{current_file} = $path;
    }
    $dialog->Destroy();
}

sub OnSave {
    my ($self) = @_;
    my $path = $self->{current_file};
    unless ($path) {   # "Save As" if no filename yet
        my $d = Wx::FileDialog->new($self, "Save As",
                   "", "", "*.txt", wxFD_SAVE);
        return if $d->ShowModal() != wxID_OK;
        $path = $d->GetPath();
        $d->Destroy();
    }
    open my $fh, '>', $path or die $!;
    print {$fh} $self->{editor}->GetValue();
    close $fh;
    $self->SetStatusText("Saved: $path");
}

package main;
EditorApp->new()->MainLoop();

Best Practices & Tips

1. Separate logic from GUI. Keep business logic in plain Perl subroutines or modules. Your GUI code should only call into those functions — never compute things inside a callback directly.
2. Use strict and warnings. GUI code involves many closures and references. Typos in variable names silently create new ones — use strict catches these immediately.
3. Don't block the event loop. Long-running work (file reads, network calls) will freeze the UI. Use $mw->update() periodically in loops, or offload work with Tk::After timers for Tk, or threads/async patterns for Wx.
4. Prefer grid over pack for forms. As soon as you have more than a few widgets, grid produces cleaner, more maintainable layouts. Never mix pack and grid inside the same container.
5. Store widget references in a hash. Instead of proliferating $button1, $button2 variables, use a %w hash: $w{submit} = $mw->Button(…). Scales to large UIs without namespace pollution.
6. Test on all target platforms early. Font sizes, widget padding, and dialog behavior differ between Windows, macOS, and Linux — even for the same toolkit. Run your app on each OS before shipping.
7. Use Wx::XmlResource for complex layouts. For large Wx applications, define your UI in an XML layout file (.xrc) and load it at runtime. This separates design from code.

Resources