HTMX - interaktywność bez JavaScriptu

W erze zdominowanej przez złożone frameworki JavaScript takie jak React, Vue czy Angular, pojawia się biblioteka, która proponuje radykalnie inne podejście do budowania interaktywnych aplikacji webowych. HTMX pozwala tworzyć dynamiczne interfejsy użytkownika bezpośrednio z poziomu HTML, bez pisania ani jednej linii JavaScriptu. Brzmi jak powrót do przeszłości? Wręcz przeciwnie - to ewolucja podejścia hypermedia, które stało się fundamentem nowoczesnego webu.

W tym artykule przyjrzymy się filozofii HTMX, omówimy kluczowe atrybuty i mechanizmy, pokażemy praktyczne wzorce implementacyjne oraz porównamy to podejście z popularnymi frameworkami SPA.

Filozofia HTMX - HTML over the Wire#

HTMX opiera się na koncepcji HTML over the Wire (HOTW), która zakłada, że serwer powinien zwracać gotowe fragmenty HTML zamiast surowych danych JSON. To powrót do klasycznego modelu hypermedia, w którym HTML jest pełnoprawnym medium komunikacji między klientem a serwerem.

Tradycyjne podejście SPA wygląda tak:

1. Przeglądarka wysyła żądanie AJAX
2. Serwer zwraca dane JSON
3. JavaScript po stronie klienta parsuje JSON
4. JavaScript generuje HTML i aktualizuje DOM

HTMX upraszcza ten przepływ:

1. Przeglądarka wysyła żądanie AJAX (dzięki atrybutom HTMX)
2. Serwer zwraca gotowy fragment HTML
3. HTMX automatycznie wstawia HTML w odpowiednie miejsce w DOM

To podejście eliminuje konieczność utrzymywania logiki prezentacyjnej po stronie klienta, redukując znacząco ilość kodu JavaScript.

Instalacja HTMX#

Rozpoczęcie pracy z HTMX jest wyjątkowo proste. Wystarczy dodać jeden tag script:

<!-- Z CDN -->
<script src="https://unpkg.com/htmx.org@2.0.4"></script>

<!-- Lub pobrać lokalnie -->
<script src="/js/htmx.min.js"></script>

HTMX waży zaledwie około 14 kB po kompresji gzip - to ułamek rozmiaru typowego frameworka JavaScript.

Podstawowe atrybuty - hx-get, hx-post, hx-put, hx-delete#

HTMX rozszerza HTML o zestaw atrybutów, które pozwalają dowolnemu elementowi HTML wysyłać żądania HTTP. W standardowym HTML jedynie formularze i linki mogą inicjować żądania - HTMX znosi to ograniczenie.

hx-get - pobieranie danych#

<!-- Kliknięcie przycisku wysyła GET i ładuje wynik do #result -->
<button hx-get="/api/articles" hx-target="#result">
  Załaduj artykuły
</button>

<div id="result">
  <!-- Tutaj pojawią się artykuły -->
</div>

hx-post - wysyłanie danych#

<!-- Formularz wysyłany przez HTMX zamiast tradycyjnego submit -->
<form hx-post="/api/comments" hx-target="#comments-list" hx-swap="beforeend">
  <input type="text" name="author" placeholder="Twoje imię" required />
  <textarea name="content" placeholder="Treść komentarza" required></textarea>
  <button type="submit">Dodaj komentarz</button>
</form>

<div id="comments-list">
  <!-- Nowe komentarze będą dodawane na końcu -->
</div>

hx-put i hx-delete - aktualizacja i usuwanie#

<!-- Edycja artykułu -->
<form hx-put="/api/articles/42" hx-target="#article-42">
  <input type="text" name="title" value="Istniejący tytuł" />
  <textarea name="content">Istniejąca treść</textarea>
  <button type="submit">Zapisz zmiany</button>
</form>

<!-- Usuwanie z potwierdzeniem -->
<button
  hx-delete="/api/articles/42"
  hx-target="#article-42"
  hx-swap="outerHTML"
  hx-confirm="Czy na pewno chcesz usunąć ten artykuł?"
>
  Usuń artykuł
</button>

Każdy z tych atrybutów pozwala przekształcić dowolny element HTML - przycisk, link, div, a nawet span - w interaktywny element wysyłający żądanie HTTP do serwera.

hx-target i hx-swap - precyzyjne zarządzanie DOM#

Dwa kluczowe atrybuty HTMX odpowiadają za to, gdzie i jak wstawić odpowiedź serwera.

hx-target#

Atrybut hx-target określa, który element DOM ma zostać zaktualizowany odpowiedzią z serwera. Akceptuje selektory CSS:

<!-- Aktualizuj konkretny element po ID -->
<button hx-get="/notifications" hx-target="#notification-panel">
  Sprawdź powiadomienia
</button>

<!-- Aktualizuj element nadrzędny -->
<button hx-get="/user/profile" hx-target="closest .card">
  Odśwież profil
</button>

<!-- Aktualizuj element za pomocą selektora find -->
<div class="search-container">
  <input
    type="search"
    hx-get="/search"
    hx-target="find .results"
    name="q"
  />
  <div class="results"></div>
</div>

hx-swap#

Atrybut hx-swap kontroluje sposób wstawiania treści. Dostępne strategie:

<!-- innerHTML (domyślnie) - zastąp zawartość elementu -->
<div hx-get="/content" hx-swap="innerHTML">Zostanie zastąpione</div>

<!-- outerHTML - zastąp cały element -->
<div hx-get="/content" hx-swap="outerHTML">Cały div zostanie zastąpiony</div>

<!-- beforeend - dodaj na końcu elementu -->
<ul hx-get="/more-items" hx-swap="beforeend">
  <li>Istniejący element</li>
  <!-- Nowe elementy pojawią się tutaj -->
</ul>

<!-- afterbegin - dodaj na początku elementu -->
<ul hx-get="/new-items" hx-swap="afterbegin">
  <!-- Nowe elementy pojawią się tutaj -->
  <li>Istniejący element</li>
</ul>

<!-- beforebegin - wstaw przed elementem -->
<div hx-get="/content" hx-swap="beforebegin">
  Nowa treść pojawi się przed tym divem
</div>

<!-- afterend - wstaw za elementem -->
<div hx-get="/content" hx-swap="afterend">
  Nowa treść pojawi się za tym divem
</div>

<!-- delete - usuń element docelowy -->
<button hx-delete="/items/1" hx-target="#item-1" hx-swap="delete">
  Usuń
</button>

<!-- none - nie modyfikuj DOM -->
<button hx-post="/api/track-click" hx-swap="none">
  Śledź kliknięcie
</button>

Dodatkowo hx-swap wspiera modyfikatory:

<!-- Animacja zamiany z opóźnieniem -->
<div hx-get="/content" hx-swap="innerHTML swap:300ms">
  Płynna zamiana treści
</div>

<!-- Scroll do elementu po zamianie -->
<div hx-get="/content" hx-swap="innerHTML scroll:top">
  Po zamianie przewiń do góry
</div>

<!-- Pokazanie animacji settle -->
<div hx-get="/content" hx-swap="innerHTML settle:500ms">
  Treść z animacją
</div>

hx-trigger - kontrola zdarzeń#

Atrybut hx-trigger definiuje, jakie zdarzenie inicjuje żądanie HTTP. Domyślnie HTMX reaguje na click dla przycisków i linków, change dla pól formularza oraz submit dla formularzy.

<!-- Niestandardowe triggery -->
<div hx-get="/news" hx-trigger="every 30s">
  Automatyczne odświeżanie co 30 sekund
</div>

<!-- Trigger na najechanie myszką -->
<div hx-get="/preview" hx-trigger="mouseenter once">
  Najedź, aby załadować podgląd (tylko raz)
</div>

<!-- Trigger z opóźnieniem (debounce) -->
<input
  type="search"
  name="q"
  hx-get="/search"
  hx-trigger="keyup changed delay:300ms"
  hx-target="#search-results"
  placeholder="Szukaj..."
/>

<!-- Wiele triggerów -->
<form
  hx-post="/validate"
  hx-trigger="change, keyup delay:500ms changed"
  hx-target="#validation-result"
>
  <input type="email" name="email" />
</form>

<!-- Trigger na załadowanie elementu -->
<div hx-get="/stats" hx-trigger="load">
  Ładowanie statystyk...
</div>

<!-- Trigger na widoczność elementu (Intersection Observer) -->
<div hx-get="/lazy-content" hx-trigger="revealed">
  Załaduje się, gdy element będzie widoczny
</div>

AJAX bez JavaScriptu - praktyczne wzorce#

HTMX pozwala realizować typowe wzorce interakcji, które tradycyjnie wymagały pisania kodu JavaScript. Oto najpopularniejsze z nich.

Aktywne wyszukiwanie (Active Search)#

Wyszukiwanie w czasie rzeczywistym, znane z Google Suggest, bez jednej linii JS:

<div class="search-box">
  <input
    type="search"
    name="q"
    hx-get="/search"
    hx-trigger="keyup changed delay:300ms"
    hx-target="#search-results"
    hx-indicator=".search-spinner"
    placeholder="Wpisz frazę..."
  />
  <span class="search-spinner htmx-indicator">
    Szukam...
  </span>
</div>

<div id="search-results">
  <!-- Wyniki wyszukiwania pojawią się tutaj -->
</div>

Po stronie serwera (przykład w Pythonie z Flask):

@app.route('/search')
def search():
    query = request.args.get('q', '')
    if len(query) < 2:
        return ''
    results = Article.query.filter(
        Article.title.ilike(f'%{query}%')
    ).limit(10).all()
    return render_template('partials/search_results.html', results=results)

Nieskończone przewijanie (Infinite Scroll)#

<div id="articles-list">
  <div class="article-card">
    <h3>Artykuł 1</h3>
    <p>Treść artykułu...</p>
  </div>
  <div class="article-card">
    <h3>Artykuł 2</h3>
    <p>Treść artykułu...</p>
  </div>
  <!-- Sentinel element - ładuje więcej po scrollowaniu -->
  <div
    hx-get="/articles?page=2"
    hx-trigger="revealed"
    hx-swap="outerHTML"
    hx-indicator="#loading-spinner"
  >
    <div id="loading-spinner" class="htmx-indicator">
      Ładowanie kolejnych artykułów...
    </div>
  </div>
</div>

Serwer zwraca kolejne artykuły wraz z nowym sentinelem:

<!-- Odpowiedź serwera dla /articles?page=2 -->
<div class="article-card">
  <h3>Artykuł 3</h3>
  <p>Treść artykułu...</p>
</div>
<div class="article-card">
  <h3>Artykuł 4</h3>
  <p>Treść artykułu...</p>
</div>
<!-- Nowy sentinel dla następnej strony -->
<div
  hx-get="/articles?page=3"
  hx-trigger="revealed"
  hx-swap="outerHTML"
>
  Ładowanie...
</div>

Walidacja formularzy w czasie rzeczywistym#

<form hx-post="/register" hx-target="#form-messages">
  <div class="form-group">
    <label for="email">Email</label>
    <input
      type="email"
      id="email"
      name="email"
      hx-post="/validate/email"
      hx-trigger="change, keyup delay:500ms changed"
      hx-target="next .validation-message"
    />
    <span class="validation-message"></span>
  </div>

  <div class="form-group">
    <label for="username">Nazwa użytkownika</label>
    <input
      type="text"
      id="username"
      name="username"
      hx-post="/validate/username"
      hx-trigger="change, keyup delay:500ms changed"
      hx-target="next .validation-message"
    />
    <span class="validation-message"></span>
  </div>

  <div class="form-group">
    <label for="password">Hasło</label>
    <input type="password" id="password" name="password" />
  </div>

  <button type="submit">Zarejestruj się</button>
  <div id="form-messages"></div>
</form>

Odpowiedź serwera dla walidacji:

@app.route('/validate/email', methods=['POST'])
def validate_email():
    email = request.form.get('email', '')
    if not re.match(r'^[^@]+@[^@]+\.[^@]+$', email):
        return '<span class="validation-message error">Nieprawidłowy format email</span>'
    if User.query.filter_by(email=email).first():
        return '<span class="validation-message error">Ten email jest już zajęty</span>'
    return '<span class="validation-message success">Email dostępny</span>'

Edycja inline (Click to Edit)#

<!-- Tryb wyświetlania -->
<div id="user-name" hx-get="/user/1/edit" hx-trigger="click" hx-swap="outerHTML">
  <span class="editable">Jan Kowalski</span>
  <small>(kliknij aby edytować)</small>
</div>

Serwer zwraca formularz edycji:

<!-- Odpowiedź z /user/1/edit -->
<form id="user-name" hx-put="/user/1" hx-target="this" hx-swap="outerHTML">
  <input type="text" name="name" value="Jan Kowalski" autofocus />
  <button type="submit">Zapisz</button>
  <button hx-get="/user/1" hx-target="#user-name" hx-swap="outerHTML">Anuluj</button>
</form>

Integracja z popularnymi frameworkami backendowymi#

HTMX jest niezależny od backendu - współpracuje doskonale z każdym serwerem, który potrafi zwracać HTML. Oto przykłady integracji z najpopularniejszymi frameworkami.

Django#

Django i HTMX to naturalne połączenie dzięki systemowi szablonów Django:

# views.py
from django.shortcuts import render
from django.http import HttpResponse
from .models import Task

def task_list(request):
    tasks = Task.objects.all()
    if request.headers.get('HX-Request'):
        return render(request, 'partials/task_list.html', {'tasks': tasks})
    return render(request, 'tasks/index.html', {'tasks': tasks})

def create_task(request):
    if request.method == 'POST':
        task = Task.objects.create(
            title=request.POST['title'],
            description=request.POST.get('description', '')
        )
        return render(request, 'partials/task_item.html', {'task': task})

def delete_task(request, task_id):
    Task.objects.filter(id=task_id).delete()
    return HttpResponse('')

<!-- templates/tasks/index.html -->
{% extends "base.html" %}

{% block content %}
<h1>Lista zadań</h1>

<form hx-post="{% url 'create_task' %}" hx-target="#task-list" hx-swap="beforeend">
  {% csrf_token %}
  <input type="text" name="title" placeholder="Nowe zadanie..." required />
  <button type="submit">Dodaj</button>
</form>

<div id="task-list">
  {% for task in tasks %}
    {% include "partials/task_item.html" %}
  {% endfor %}
</div>
{% endblock %}

Istnieje także dedykowany pakiet django-htmx, który ułatwia wykrywanie żądań HTMX i dodaje middleware z przydatnymi helperami.

Laravel#

// routes/web.php
Route::get('/tasks', [TaskController::class, 'index']);
Route::post('/tasks', [TaskController::class, 'store']);
Route::delete('/tasks/{task}', [TaskController::class, 'destroy']);

// TaskController.php
class TaskController extends Controller
{
    public function index(Request $request)
    {
        $tasks = Task::latest()->get();

        if ($request->header('HX-Request')) {
            return view('partials.task-list', compact('tasks'));
        }

        return view('tasks.index', compact('tasks'));
    }

    public function store(Request $request)
    {
        $task = Task::create($request->validate([
            'title' => 'required|string|max:255',
        ]));

        return view('partials.task-item', compact('task'));
    }

    public function destroy(Task $task)
    {
        $task->delete();
        return response('', 200);
    }
}

<!-- resources/views/partials/task-item.blade.php -->
<div class="task-item" id="task-{{ $task->id }}">
  <span>{{ $task->title }}</span>
  <button
    hx-delete="/tasks/{{ $task->id }}"
    hx-target="#task-{{ $task->id }}"
    hx-swap="outerHTML"
    hx-confirm="Usunąć zadanie?"
  >
    Usuń
  </button>
</div>

Ruby on Rails#

Rails z wbudowanym systemem partiali idealnie współgra z HTMX:

# app/controllers/tasks_controller.rb
class TasksController < ApplicationController
  def index
    @tasks = Task.all.order(created_at: :desc)
  end

  def create
    @task = Task.create!(task_params)
    render partial: 'tasks/task', locals: { task: @task }
  end

  def destroy
    Task.find(params[:id]).destroy
    head :ok
  end

  private

  def task_params
    params.require(:task).permit(:title, :description)
  end
end

WebSocket i SSE - komunikacja w czasie rzeczywistym#

HTMX wspiera komunikację w czasie rzeczywistym poprzez rozszerzenia WebSocket i Server-Sent Events (SSE).

Server-Sent Events (SSE)#

SSE to jednokierunkowy kanał komunikacji serwer-klient, idealny dla powiadomień i aktualizacji na żywo:

<div hx-ext="sse" sse-connect="/events/notifications">
  <div id="notifications" sse-swap="notification" hx-swap="beforeend">
    <!-- Nowe powiadomienia będą dodawane automatycznie -->
  </div>

  <div id="online-count" sse-swap="online-count">
    <!-- Liczba użytkowników online aktualizowana w czasie rzeczywistym -->
  </div>
</div>

Przykład serwera SSE w Pythonie:

from flask import Response
import json

@app.route('/events/notifications')
def notification_stream():
    def generate():
        while True:
            # Pobierz nowe powiadomienia
            notifications = get_pending_notifications()
            for notification in notifications:
                data = render_template('partials/notification.html',
                                       notification=notification)
                yield f"event: notification\ndata: {data}\n\n"
            time.sleep(1)
    return Response(generate(), mimetype='text/event-stream')

WebSocket#

<div hx-ext="ws" ws-connect="/ws/chat">
  <div id="chat-messages">
    <!-- Wiadomości czatu pojawiają się automatycznie -->
  </div>

  <form ws-send>
    <input type="text" name="message" placeholder="Napisz wiadomość..." />
    <button type="submit">Wyślij</button>
  </form>
</div>

HTMX vs React/Vue - kiedy wybrać co?#

Porównanie HTMX z frameworkami SPA to nie kwestia „lepsze vs gorsze", ale raczej „odpowiednie narzędzie do odpowiedniego zadania".

Kiedy HTMX jest lepszym wyborem#

• Aplikacje CRUD - panele administracyjne, systemy zarządzania treścią, dashboardy
• Strony z dynamicznymi elementami - formularze, wyszukiwarki, filtrowanie tabel
• Projekty z małym zespołem - jeden fullstack developer zamiast oddzielnego frontendu i backendu
• Istniejące aplikacje server-rendered - dodawanie interaktywności do Django, Rails, Laravel bez przepisywania na SPA
• Prototypowanie - szybkie tworzenie MVP z minimalnym nakładem pracy
• SEO-first aplikacje - blogi, strony firmowe, e-commerce z SSR

Kiedy React/Vue jest lepszym wyborem#

• Zaawansowane interfejsy użytkownika - edytory graficzne, mapy interaktywne, aplikacje real-time
• Aplikacje offline-first - Progressive Web Apps z Service Workers
• Złożone stany po stronie klienta - wielopoziomowe formularze, wizardy, drag-and-drop
• Ekosystem i biblioteki - ogromna liczba gotowych komponentów
• Duże zespoły frontendowe - ustandaryzowana architektura komponentowa

Porównanie techniczne#

| Cecha | HTMX | React/Vue | |-------|------|-----------| | Rozmiar | ~14 kB | ~40-100 kB+ | | Język | HTML + atrybuty | JavaScript/TypeScript | | Stan aplikacji | Serwer | Klient | | Renderowanie | Serwer | Klient (lub SSR) | | Krzywa uczenia | Niska | Średnia-wysoka | | Narzędzia build | Brak | Webpack/Vite | | SEO | Natywne | Wymaga SSR/SSG | | Offline | Ograniczone | Pełne wsparcie | | Testowanie | Testy integracyjne | Unit + integracyjne |

Podejście Hypermedia - powrót do korzeni#

HTMX reprezentuje szerszy trend w branży - powrót do podejścia hypermedia. Zamiast traktować HTML jako „głupi" format prezentacji, a całą logikę przenosić do JavaScriptu, podejście hypermedia uznaje HTML za pełnoprawne medium komunikacji w aplikacjach webowych.

Kluczowe zasady podejścia hypermedia:

• Serwer zarządza stanem - brak duplikacji stanu między klientem a serwerem
• HTML jako format wymiany - serwer zwraca gotowe fragmenty interfejsu
• Progresywne ulepszanie - aplikacja działa nawet bez JavaScriptu (w podstawowej formie)
• Prostota architektury - brak potrzeby oddzielnego API i aplikacji frontendowej
• Mniej kodu - typowo 67% mniej kodu w porównaniu do podejścia SPA

HATEOAS w praktyce#

HTMX naturalnie implementuje zasadę HATEOAS (Hypermedia as the Engine of Application State), gdzie serwer kontroluje dostępne akcje poprzez zwracane linki i formularze:

<!-- Serwer zwraca różne akcje w zależności od stanu -->
<div class="article" id="article-42">
  <h2>Tytuł artykułu</h2>
  <p>Treść artykułu...</p>

  <!-- Akcje dostępne dla autora -->
  <div class="actions">
    <button hx-get="/articles/42/edit" hx-target="#article-42">Edytuj</button>
    <button hx-post="/articles/42/publish" hx-target="#article-42">Opublikuj</button>
    <button hx-delete="/articles/42" hx-target="#article-42" hx-swap="outerHTML">Usuń</button>
  </div>
</div>

Zaawansowane techniki HTMX#

Wskaźniki ładowania#

<button hx-get="/slow-request" hx-indicator="#spinner">
  Załaduj dane
  <span id="spinner" class="htmx-indicator">
    <img src="/spinner.gif" alt="Ładowanie..." />
  </span>
</button>

<style>
  .htmx-indicator {
    display: none;
  }
  .htmx-request .htmx-indicator,
  .htmx-request.htmx-indicator {
    display: inline;
  }
</style>

Nagłówki żądań i odpowiedzi#

HTMX automatycznie wysyła przydatne nagłówki z każdym żądaniem:

• HX-Request: true - identyfikuje żądanie HTMX
• HX-Target - ID elementu docelowego
• HX-Trigger - ID elementu, który wywołał żądanie
• HX-Current-URL - bieżący URL strony

Serwer może kontrolować zachowanie HTMX poprzez nagłówki odpowiedzi:

# Przekierowanie po stronie klienta
response.headers['HX-Redirect'] = '/dashboard'

# Odświeżenie całej strony
response.headers['HX-Refresh'] = 'true'

# Wywołanie zdarzenia po stronie klienta
response.headers['HX-Trigger'] = json.dumps({
    'showToast': {'message': 'Zapisano pomyślnie!', 'type': 'success'}
})

Rozszerzenia HTMX#

HTMX oferuje system rozszerzeń, które dodają dodatkowe funkcjonalności:

<!-- Rozszerzenie class-tools -->
<div hx-ext="class-tools">
  <div classes="add highlight:1s, remove highlight:3s">
    Animowana klasa CSS
  </div>
</div>

<!-- Rozszerzenie response-targets - obsługa błędów -->
<form
  hx-ext="response-targets"
  hx-post="/submit"
  hx-target="#success"
  hx-target-422="#errors"
  hx-target-500="#server-error"
>
  <!-- formularz -->
</form>

Kiedy HTMX to właściwy wybór?#

HTMX sprawdza się najlepiej, gdy:

• Twoja aplikacja jest server-rendered - Django, Laravel, Rails, Spring, ASP.NET
• Potrzebujesz dynamicznych elementów, ale nie pełnego SPA - wyszukiwarki, filtry, formularze
• Chcesz zmniejszyć złożoność projektu - jeden stack zamiast dwóch
• Zespół ma silne kompetencje backendowe - brak konieczności nauki frameworka JS
• Zależy Ci na wydajności - mniejszy bundle, szybsze ładowanie
• Budujesz MVP lub prototyp - szybkie iterowanie bez overhead frameworka
• Modernizujesz istniejącą aplikację - stopniowe dodawanie interaktywności

HTMX nie jest jednak srebrną kulą. Dla aplikacji wymagających zaawansowanego zarządzania stanem po stronie klienta, pracy offline, lub złożonych animacji, frameworki takie jak React czy Vue pozostają lepszym wyborem.

Podsumowanie#

HTMX to biblioteka, która kwestionuje dominujący paradygmat budowania aplikacji webowych. Zamiast przenosić coraz więcej logiki na stronę klienta, proponuje powrót do modelu, w którym serwer jest centrum aplikacji, a HTML jest pełnoprawnym medium komunikacji. Dzięki prostym atrybutom HTML programista może budować interaktywne interfejsy bez pisania JavaScriptu, znacznie redukując złożoność projektu i przyspieszając rozwój.

Rosnąca popularność HTMX - ponad 30 000 gwiazdek na GitHubie i aktywna społeczność - pokazuje, że podejście hypermedia rezonuje z coraz większą liczbą programistów, którzy szukają prostszych sposobów na budowanie nowoczesnych aplikacji webowych.

---

Szukasz ekspertów od nowoczesnych technologii webowych?#

MDS Software Solutions Group pomaga firmom wybierać i wdrażać odpowiednie technologie do budowania wydajnych aplikacji webowych. Niezależnie od tego, czy rozważasz HTMX dla prostszej architektury, czy potrzebujesz zaawansowanego rozwiązania SPA - nasz zespół doświadczonych programistów pomoże Ci podjąć najlepszą decyzję.

Oferujemy:

• Projektowanie i budowanie aplikacji webowych z wykorzystaniem nowoczesnych technologii
• Modernizację istniejących systemów i dodawanie interaktywności
• Doradztwo technologiczne i audyty architektury
• Integracje backendowe z Django, Laravel, Rails i innymi frameworkami

Skontaktuj się z nami i porozmawiajmy o Twoim projekcie.