My project 2 : Currency Converter(with Python + Flask)

💱 Building a Currency Converter Using Flask

I created this project because I needed a simple way to check currency differences while living in Switzerland. As a Korean currently residing here, I often shop in nearby countries like Germany or Austria, or sometimes order items from Korea. Every time, I found myself wondering how the prices compared to Swiss Francs and what the actual cost would be after conversion.

This project was born out of that everyday frustration. By using an external API, the converter provides real-time exchange rates and helps calculate accurate values instantly. It’s a practical tool built from a real need — and a great learning experience at the same time.

📂 1. Project Structure

currency_converter/
│── app.py
└── templates/
    └── index.html

🧠 2. How It Works

  • User enters amount + selects currencies
  • Flask sends a request to the Frankfurter API
  • The API returns live exchange rates in JSON
  • Flask calculates the converted amount and renders it in the template
  • Includes error handling + same-currency logic

🖥️ 3. Backend Code (app.py)

from flask import Flask, render_template, request
import requests

app = Flask(__name__)

API_URL = "https://api.frankfurter.app/latest"   # Frankfurter API endpoint

@app.route("/", methods=["GET", "POST"])
def index():
    result = None

    if request.method == "POST":
        amount = float(request.form.get("amount"))
        from_currency = request.form.get("from")
        to_currency = request.form.get("to")

        # Prevent conversion between identical currencies
        if from_currency == to_currency:
            result = {
                "from": from_currency,
                "to": to_currency,
                "amount": amount,
                "converted": amount,
                "rate": 1.0
            }
            return render_template("index.html", result=result)

        # Request to Frankfurter API
        url = f"{API_URL}?from={from_currency}&to={to_currency}"
        response = requests.get(url)
        data = response.json()

        print("API Response:", data)

        try:
            rate = data["rates"][to_currency]
            converted = round(amount * rate, 2)

            result = {
                "from": from_currency,
                "to": to_currency,
                "amount": amount,
                "converted": converted,
                "rate": rate
            }
        except KeyError:
            result = {
                "error": "Conversion failed. Please check the currency codes."
            }

    return render_template("index.html", result=result)

if __name__ == "__main__":
    app.run(debug=True)

🌐 4. Frontend Template (index.html)

<!DOCTYPE html>
<html>
<head>
    <title>Currency Converter</title>
    <style>
        body { 
            font-family: 'Inter', sans-serif; 
            padding: 20px; 
            display: flex;
            flex-direction: column;
            align-items: center;
            background-color: #f4f7f6;
        }
        h1 { color: #2c3e50; margin-bottom: 20px; }
        form {
            display: flex;
            flex-direction: column;
            align-items: center;
            padding: 20px;
            background: #ffffff;
            border-radius: 10px;
            box-shadow: 0 4px 12px rgba(0,0,0,0.1);
        }
        input, select, button { 
            padding: 12px; 
            margin: 8px 0; 
            border: 1px solid #ccc;
            border-radius: 6px;
            width: 100%;
            box-sizing: border-box;
        }
        button {
            background-color: #3498db;
            color: white;
            font-weight: bold;
            cursor: pointer;
        }
        button:hover { background-color: #2980b9; }
        .result-box {
            margin-top: 30px;
            padding: 20px;
            background: #ecf0f1;
            border-radius: 10px;
            max-width: 400px;
            width: 100%;
            text-align: center;
        }
        .error-message { color: #e74c3c; font-weight: bold; }
    </style>

    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;600;700&display=swap" rel="stylesheet">
</head>
<body>

    <h1>Currency Converter</h1>

    <form method="POST" style="width: 100%; max-width: 400px;">
        <input type="number" step="0.01" name="amount" placeholder="Enter Amount" required>

        <select name="from">
            <option value="CHF">CHF (Swiss Franc)</option>
            <option value="USD">USD (US Dollar)</option>
            <option value="EUR">EUR (Euro)</option>
            <option value="KRW">KRW (South Korean Won)</option>
        </select>

        <select name="to">
            <option value="KRW">KRW (South Korean Won)</option>
            <option value="EUR">EUR (Euro)</option>
            <option value="USD">USD (US Dollar)</option>
            <option value="CHF">CHF (Swiss Franc)</option>
        </select>

        <button type="submit">Convert</button>
    </form>

    {% if result %}
        <div class="result-box">
            {% if result.error %}
                <p class="error-message">Error: {{ result.error }}</p>
            {% else %}
                <h3>Result</h3>
                <p>
                    {{ result.amount }} {{ result.from }} →
                    <span style="font-weight: bold; color: #27ae60;">
                        {{ result.converted }} {{ result.to }}
                    </span>
                </p>
                <p>Exchange Rate: 1 {{ result.from }} = {{ result.rate }} {{ result.to }}</p>
            {% endif %}
        </div>
    {% endif %}

</body>
</html>

📘 5. What I Learned

  • How to build a web form and process POST requests in Flask
  • How to fetch live data from an external API
  • How to handle JSON responses safely
  • How to render data dynamically with Jinja2
  • Basic UI styling with HTML + CSS

🔧 6. Try It Yourself — Easy Improvements

Here are some beginner-friendly tasks you can try on your own:

  • Add input validation — prevent empty or negative numbers.
  • Show conversion history — save each result to a list or database.
  • Add more currencies — expand the dropdown list.
  • Improve the UI — center the layout, add icons, or change colors.
  • Make a mobile-friendly version — adjust spacing for small screens.

Small steps like these help you understand Flask more deeply.
Try one or two and watch how quickly the project evolves!

Give your AI Studio deployed app a custom URL

So, you’ve just built an incredible AI application using Build in Google’s AI Studio. You hit Deploy, the code flies through the ether, and your app is live! But then you look at the URL. It’s something like: https://burning-man-animal-cuddle-614365371127.us-west1.run.app/.

While I personally love the vibe of “Burning Man Animal Cuddle”, your users might find it a bit… suspicious. You bought a cool domain on Namecheap (like vibe-compose.com), and you want to use that instead.

If you’ve never connected a Google Cloud Run service to a third-party registrar like Namecheap, the “DNS Dance” can be confusing. Here is exactly how to do it without pulling your hair out.

Step 1: Add the Mapping in Cloud Run

First, head over to your Google Cloud Console and navigate to Cloud Run domains. Find your project in the dropdown list in the top left (ex: Generative Language Client). You’ll see a button to Add Mapping in the Domain Mappings section.

In the dropdown:

  • Select service: Pick your app.

  • Select a verified domain: Choose “Verify a new domain…”

  • Base domain: Type your root domain (e.g., vibe-compose.com). Do not type www yet. We start with the root.

Step 2: The Verification Dance

Google needs to know you actually own the domain before they route traffic to it. When you click verify, a modal will pop up giving you a TXT record.

Once you’ve entered in your website name and hit Continue, copy that long string of text. It’s time to leave Google for a moment and head to Namecheap.

  • Log into Namecheap.

  • Go to your Domain List -> Manage -> Advanced DNS.

  • Click Add New Record.

  • Select TXT Record.

  • Host: @

  • Value: Paste that Google verification string here.

  • TTL: Automatic.

  • Save changes.

Coffee Break: DNS changes usually take a while. Wait 2 minutes, then go back to the Google Cloud tab and press VERIFY.

Step 3: Mapping the “Naked” Domain

Once verified, the hard part begins. You want your site to load at vibe-compose.com (no www). This is called the “Naked” or “Root” domain.

Cloud Run does not use CNAMEs for root domains. It uses A Records (IPv4) and AAAA Records (IPv6). Cloud Run will display a list of IP addresses. You need to add all of them to Namecheap.

In Namecheap Advanced DNS, your list should look like the image above:

  • 4 A Records: Host is @, Values are the IPs ending in .32.21, .34.21, .36.21, and .38.21.

  • 4 AAAA Records: Host is @, Values are the long IPv6 addresses.

Step 4: Don’t Forget the www

If you stop now, vibe-compose.com will work, but www.vibe-compose.com will crash. We need to map the subdomain too.

  • Go back to Cloud Run Domain Mappings.

  • Click Add Mapping again.

  • Type www.vibe-compose.com.

  • Google will tell you to add a CNAME.

  • Back in Namecheap, add one final record:

  • Type: CNAME Record

  • Host: www

  • Value: ghs.googlehosted.com.

⚠️ The “Gotcha”: Many devs accidentally paste ghs.googlehosted.com into the “Host” field. Don’t do that! The Host is www. If Namecheap adds a period at the end, that should be okay.

Step 5: The spinning wheel of patience

Once your DNS records are in, head back to the Cloud Run dashboard. You will see your domains listed with a yellow spinner or a green checkmark.

What is happening now?

DNS Propagation: Google is checking to see if Namecheap updated (can take 10 mins to 24 hours).

Certificate Provisioning: Once DNS is found, Google automatically creates a managed SSL certificate for you.

Conclusion

Taking the extra 5 minutes to map a custom domain adds a massive layer of polish to your projects. Now, instead of sending people to burning-man-animal-cuddle, you can send them to vibe-compose.com.

(Though, honestly, I’m going to miss the animal cuddles).

Happy Coding! 🚀

Why 95% of AI Agent Projects Never Reach Production (And How We’re Fixing It)

If you’ve tried to deploy AI agents to production, you know the pain.

The POC works beautifully on your laptop. But then reality hits: orchestration complexity, observability gaps, compliance requirements, infrastructure management, and integration hell.

The numbers don’t lie:
95% of agentic AI projects never make it past proof-of-concept (MIT’s research blames the technology).

The Problem
Enterprises are rushing to build AI agents, but the DevOps tooling hasn’t caught up. You’re stuck duct-taping together:

  • Custom orchestration scripts that break under load
  • Makeshift observability for debugging agent behavior
  • Manual compliance and security configurations
  • Infrastructure that doesn’t auto-scale or self-heal

Each project reinvents the wheel. Your AI team shouldn’t be infrastructure engineers.

Enter Phinite.ai (http://Phinite.ai)

We built the DevOps platform that AI agents deserve. Think of it as the missing infrastructure layer between your agent code and production deployment.

What makes it different?

🎯 No-code orchestration

Drag-and-drop multi-agent workflows. Compatible with LangGraph, AutoGen, CrewAI—bring your own framework.

☁️ Cloud agnostic

Deploy anywhere: Azure, AWS, GCP, or on-premises. No vendor lock-in. Your infrastructure, your choice.

🔒 Enterprise-ready from day one

Built-in security, compliance, and role-based access controls. Production-grade from the start.

📈 Auto-scaling & self-healing

Kubernetes-native architecture that scales with demand and recovers from failures automatically.

🔍 Observability built-in

Track agent behavior, debug conversations, and optimize performance without cobbling together monitoring tools.

⚡ 10x faster deployment

What takes weeks of infrastructure work now takes hours. Deploy agents, not YAML.

Join our Beta 🚀

We’re opening up our beta program to developers and teams building agentic AI systems.

Beta perks:

  • Free platform credits to build and deploy agents
  • Direct access to our founding team
  • Influence the product roadmap
  • Preferred early adopter pricing

Who should apply:

  • Developers building AI agent applications
  • Engineering teams exploring multi-agent architectures
  • DevOps professionals managing AI infrastructure
  • Anyone frustrated with current agent deployment tools

👉 Apply here: https://app.youform.com/forms/6nwdpm0y

How We Build AR Projects: Full Development Process Explained Step by Step

Augmented reality (AR) is no longer a futuristic concept—it’s here, transforming industries, reshaping customer experiences, and redefining how we interact with digital content. From retail and education to healthcare and entertainment, AR offers businesses a unique way to merge the physical and digital worlds.

At Zoolatech, we specialize in building immersive augmented reality projects that help brands stand out, engage users, and deliver measurable business results. But behind every impressive AR experience lies a structured, methodical development process. In this article, we’ll take you through each stage of our workflow, explaining how we turn an idea into a fully functional AR solution—step by step.

Step 1: Understanding the Vision and Defining Objectives

Every successful AR project starts with a clear understanding of the client’s goals. Before diving into design or development, our team at Zoolatech focuses on discovering the why behind the project.

Key Questions We Ask

What business problem are we solving?

Who is the target audience?

What type of AR experience will deliver the most value (marketing campaign, education tool, e-commerce feature, etc.)?

What are the measurable success criteria (engagement, conversions, brand awareness)?

We conduct workshops and brainstorming sessions with the client to gather insights. This step ensures the project has a strategic direction from the start. It’s not just about building cool tech—it’s about creating meaningful experiences that align with business goals.

Example Scenario

Imagine a retail brand that wants to use AR to let customers “try on” furniture in their homes before buying. The objective is to boost confidence and reduce return rates. Once this purpose is defined, the rest of the process becomes much clearer.

Step 2: Research and Feasibility Study

After defining objectives, our team conducts in-depth research. We analyze market trends, competitors, and technological possibilities to find the best approach for the project.

What We Evaluate

Platform feasibility: Should the app be built for iOS, Android, or as a web-based experience?

AR frameworks: Comparison of ARKit, ARCore, Unity, Unreal Engine, and WebAR solutions.

Hardware requirements: Understanding the device capabilities needed for an optimal experience.

User experience implications: How AR fits naturally into user interactions.

This research phase ensures that our solution is realistic, scalable, and delivers the best performance possible.

At Zoolatech, we always balance innovation with practicality—our goal is to push boundaries while maintaining technical reliability.

Step 3: Concept Design and Storyboarding

Once we know what’s possible, we move into creative design. Here, imagination meets strategy. Our designers, AR experts, and storytellers work together to visualize the user experience from start to finish.

Storyboarding and UX Flow

We start by mapping the entire user journey. Storyboards and wireframes help us outline how users will interact with digital elements in the real world. Each touchpoint—scanning an object, triggering an animation, or engaging with 3D models—is carefully planned.

Visual Style and Brand Identity

Next, we develop the visual direction. We ensure that every aspect of the AR experience aligns with the brand’s identity—colors, tone, and style.

For instance, if we’re creating an AR experience for a fashion brand, we might emphasize elegance and simplicity. For an educational AR tool, clarity and engagement become the top priorities.

This stage bridges creativity with purpose, ensuring the AR experience is both functional and emotionally engaging.

Step 4: Technical Architecture and Prototype Development

Once the concept is finalized, our engineers take over. This is where Zoolatech’s technical expertise truly shines.

Building the Foundation

We create the system architecture that supports the AR experience. This includes:

Backend infrastructure for data management

API integrations

Real-time rendering systems

Tracking and recognition algorithms

Depending on the complexity, we might build a quick proof of concept (POC) to validate the technical approach. This small-scale prototype helps us confirm that our chosen tools and frameworks will work seamlessly in real-world conditions.

Tools and Technologies

We typically use tools like:

Unity 3D or Unreal Engine for advanced AR development

ARKit (iOS) and ARCore (Android) for mobile apps

Three.js or 8th Wall for web-based AR experiences

Blender or Maya for 3D modeling and animation

This foundation allows us to build stable, high-performance AR applications that can run smoothly across devices.

Step 5: 3D Modeling and Asset Creation

The visual assets are the heart of every AR experience. Whether it’s a virtual product, a 3D character, or an animated environment, the assets determine how realistic and engaging the final experience will be.

Creating Realistic 3D Assets

Our 3D artists at Zoolatech meticulously model every element. Depending on the project’s goal, the assets can range from stylized visuals to hyper-realistic renders.

We use advanced texturing and lighting techniques to ensure that digital objects integrate naturally into the user’s real environment. This attention to detail enhances immersion and believability.

Optimization for Performance

AR apps must run efficiently, even on mid-range devices. Therefore, we focus heavily on optimization—reducing polygon counts, compressing textures, and balancing quality with speed.

This ensures that the AR experience is visually stunning without overloading the device’s processing power.

Step 6: Development and Integration

With assets and architecture ready, our developers begin full-scale implementation. This is the most intensive stage of the AR project lifecycle.

Core Development Tasks

Implementing object tracking and spatial recognition

Integrating animations and interactions

Connecting backend systems and databases

Building user interface elements

Testing device compatibility

We follow agile methodologies, breaking the development into sprints. This approach allows for continuous testing and iteration, ensuring flexibility and transparency for our clients.

Real-World Testing

AR development requires continuous field testing. Lighting conditions, surfaces, and camera performance all affect how AR behaves. That’s why we test in various real-world environments to fine-tune the user experience.

This hands-on validation process helps ensure that our augmented reality projects perform flawlessly across contexts.

Step 7: Quality Assurance and Usability Testing

Quality assurance (QA) is not just about fixing bugs—it’s about guaranteeing a smooth, intuitive, and immersive experience.

Multi-Stage Testing Approach

Functional testing: Verifying all features work as intended.

Performance testing: Measuring speed, responsiveness, and stability.

UX testing: Observing how users interact with the AR experience.

Cross-platform testing: Ensuring compatibility with various devices and OS versions.

Our QA team replicates real-world conditions—poor lighting, different surfaces, and varying device cameras—to ensure reliability under all circumstances.

Beta Testing

Before launch, we often release a beta version to a small group of users. This helps us collect feedback, identify usability issues, and refine interactions.

The goal is to eliminate friction points and ensure that the final experience is intuitive for first-time users.

Step 8: Deployment and Launch

Once testing is complete, we prepare for deployment. Depending on the project type, this could mean:

Submitting to the App Store or Google Play

Hosting on a web platform for browser-based experiences

Integrating into an existing app or product ecosystem

Launch Strategy

Our launch process includes final performance optimization, analytics setup, and scalability testing.

At Zoolatech, we also help clients create marketing materials—demo videos, user guides, and social media teasers—to support the AR project’s public release.

The goal is to ensure a seamless go-live experience where everything—from app performance to user onboarding—is flawless.

Step 9: Post-Launch Support and Maintenance

AR technology evolves rapidly, and maintaining performance requires continuous updates.

After launch, we provide ongoing support to monitor performance, fix issues, and update features based on user feedback.

Maintenance Includes

Regular updates for new OS versions

Security patches and bug fixes

Adding new features or content

Analyzing user data for future improvements

This commitment to long-term success is one of the reasons clients trust Zoolatech for their AR development needs. We don’t just build and walk away—we partner with our clients for sustainable growth.

Step 10: Data Analysis and Continuous Improvement

One of the biggest advantages of digital experiences like AR is the ability to collect actionable data.

We help clients track:

Engagement metrics: Time spent, number of interactions

Conversion rates: How AR influences purchase behavior

User feedback: Ratings, reviews, and survey responses

Technical data: Performance logs, device usage, session stability

These insights guide future updates and improvements. Over time, this data-driven approach allows us to enhance engagement, refine UX, and maximize ROI for each augmented reality project.

Best Practices We Follow

Throughout our development process, Zoolatech adheres to industry best practices that ensure quality, scalability, and long-term value.

  1. Human-Centered Design

Every AR experience is built around the end user. We prioritize intuitive interactions, accessibility, and emotional engagement.

  1. Scalability from Day One

Our solutions are designed to evolve—whether it’s adding new content, supporting new devices, or integrating with other digital systems.

  1. Collaboration and Transparency

Clients are part of the journey from the first concept meeting to final deployment. We use collaborative tools for updates, feedback, and progress tracking.

  1. Ethical and Responsible Innovation

We ensure that our AR solutions respect privacy and use data responsibly. Transparency and trust are integral to our process.

The Zoolatech Advantage

Building augmented reality projects requires a perfect blend of creativity, technology, and strategic thinking. At Zoolatech, we combine these elements to deliver immersive AR solutions that drive real-world impact.

Our multidisciplinary team—comprising developers, designers, UX strategists, and data analysts—works together seamlessly to bring ideas to life. With expertise across industries, we’ve developed AR applications for retail, healthcare, education, and entertainment sectors.

What sets us apart is our holistic approach. We don’t just develop apps—we craft digital experiences that connect people, inspire emotion, and create measurable value.

Final Thoughts

The journey from idea to fully functional AR experience involves careful planning, technical excellence, and creative vision. By following a structured, step-by-step development process, we ensure that every project meets the highest standards of quality, performance, and user satisfaction.

At Zoolatech, we’re passionate about shaping the future through augmented reality projects that push boundaries and redefine possibilities. Whether you’re envisioning a marketing campaign, an interactive product visualization, or a cutting-edge training tool, our team is ready to turn your concept into a remarkable AR reality.

Yoyo migrate vs Golang migrate

Recently I had to integrate a database migration tool into our CI pipeline. At first we picked golang-migrate because it is popular and widely recommended. Everything looked fine until we started running real migrations.

Pretty quickly we ran into issues that made the workflow harder than expected. Stored procedures caused trouble because of delimiter handling. If a migration failed, it often ended up in a dirty state and we had to roll it back manually. There was no built-in history table, so tracking what actually happened required extra effort. And with the default settings we could only run one SQL statement per migration, which was too limiting for our use case.

After spending time trying to work around these problems, I started looking for alternatives and found yoyo-migrate. It has not been updated for about a year, but the functionality is so simple that I do not think it needs frequent releases. I decided to give it a try and it worked surprisingly well.

What I liked most is how straightforward it is. It supports multiple SQL statements, runs everything inside a transaction so you do not need to roll anything back manually, and handles stored procedures without issues. It also supports both .sql and .py migrations, which makes it very convenient for pipelines where you need to mix schema changes with data transformations or aggregation logic.

yoyo-migrate is not as popular as golang-migrate, but in my case it did the job better. It was easier to work with, caused fewer problems and fit the workflow without forcing us into hacks or manual fixes. Sometimes the less popular tool simply fits the real task better.

A Better Way to Explore kotlinx-benchmark Results with Kotlin Notebooks

Benchmarking is an important part of writing efficient Kotlin code. The kotlinx-benchmark library helps you measure and compare performance across different implementations or hardware configurations.

However, raw text results only take you so far. Sometimes you need to visualize your data, not just read it. That’s where Kotlin notebooks come in.

Kotlin notebooks combine the expressiveness of Kotlin with the interactivity of notebook-style development. They give you one convenient place where you can:

  • Load results as structured data.
  • Explore results using the DataFrame API.
  • Visualize results with charts.

Why use notebooks for benchmarking?

Let’s say you’ve run a benchmark suite and obtained text output from kotlinx.benchmark:

Benchmark                              Mode     Cnt Score    Error  Units

maps.LinearSearch                      avgt     10  12.500 ± 0.900  ms/op

maps.BinarySearch                      avgt     10   8.300 ± 0.600  ms/op

maps.HashLookup                        avgt     10   4.700 ± 0.400  ms/op

lists.Filter                           avgt     10  15.200 ± 1.200  ms/op

lists.Map                              avgt     10   9.800 ± 0.700  ms/op

The table works fine for a quick look, but once you accumulate more data, it becomes harder to navigate. Visualizing the same data gives you an instant overview of which implementations perform better and how stable the results are.

You can use Kotlin notebooks to visualise that data quickly:

You can also run the same notebook on another machine and compare the results visually, revealing performance differences between environments or commits.

Comparing benchmark results

Kotlin notebooks make it easy to analyze and plot results from one or more benchmark runs.
For example, you can:

  • Read benchmark JSON files generated by kotlinx-benchmark.
  • Convert the results into typed DataFrames.
  • Compute metrics such as percentage improvements.
  • Plot the results with Kandy charts.
  • Account for confidence intervals to perform statistically rigorous comparisons.

Several benchmark examples are available in the examples folder of the kotlinx-benchmark repository. 

Generating and sharing notebooks

Once your notebook is ready, you can:

  • Create a GitHub gist to share results quickly.
  • Commit the notebook to your project for reproducible performance tracking.
  • Publish it with JetBrains Datalore for interactive viewing online.

This workflow makes benchmark results easier to understand and share with your team.

Learn more

  • kotlinx-benchmark examples
  • Kotlin Notebook documentation

JetBrains Academy Plugin 2025.11 is Now Available

With the holidays just around the corner and the year coming to a cheerful close, we’re ringing in the final JetBrains Academy plugin update of 2025, version 2025.11!

This release focuses on the introduction of the standalone Hyperskill plugin, expands achievement-sharing to IDE-based courses, and brings a number of improvements and fixes to make your learning experience smoother than ever.

To explore the latest improvements, install the JetBrains Academy plugin or update to the latest version from Settings | Plugins in your JetBrains IDE.

Install free JetBrains Academy plugin

Dedicated Hyperskill plugin

Hyperskill learners are now getting a more streamlined and dedicated learning experience! Hyperskill is moving out of the JetBrains Academy plugin into a standalone plugin built specifically for the Hyperskill learning experience. All learning in-IDE capabilities stay the same.

This change brings several benefits:

  • Faster updates delivered directly by the Hyperskill team.
  • Simpler, cleaner navigation with everything in one place.
  • A more consistent and focused learning workflow.

The JetBrains Academy plugin will continue to support JetBrains Academy and Coursera courses, while all Hyperskill content is now available only through the new free Hyperskill Academy plugin.

Details for Hyperskill learners

If you are already working in Hyperskill, your existing projects and progress are safe and will still be there for you – no manual migration required. To continue learning in your IDE, you’ll just have to switch to the new plugin.

Here’s what you need to do:

  1. Update to the latest version of the JetBrains Academy plugin.
  2. Install the new Hyperskill Academy plugin from the Marketplace tab in your IDE and sign in with your Hyperskill account in Settings/Preferences | Tools | Hyperskill.
  3. Open your existing projects and continue learning right where you left off – everything will appear automatically once you sign in.
Install free Hyperskill Academy plugin

Hyperskill learners can also switch to the Hyperskill Academy plugin directly from their course. If you open a course you previously started in the JetBrains Academy plugin, you’ll see a notification with an option to install the Hyperskill plugin and continue the course there.

This change is all about giving you a more streamlined and reliable learning environment that’s designed to support your growth every step of the way.

If you have any questions, you can check the full FAQ in our dedicated blog post about the Hyperskill Academy plugin or get in touch with Hyperskill Support.

JetBrains Academy: Celebrate Your Achievements!

Hyperskill includes a fun feature that lets you share your progress on X and LinkedIn, and with this update, we’re bringing that same experience to our in-IDE courses.

Now, when you complete 80% of an IDE course, you’ll receive a notification in your IDE with the option to share your achievement. It’s a simple way to mark how far you’ve come, whether you want to boost your portfolio, stay motivated, or just enjoy a small moment of celebration with the community. Sharing your progress can be a great confidence boost, and it reminds you that learning isn’t just about reaching the finish line, but about appreciating the milestones along the way. Your post might even inspire someone else to start learning, too.

For the full list of issues addressed in the JetBrains Academy plugin’s 2025.11 update, see our issue tracker.

We hope you enjoy this release! As always, please share your feedback with us in the comments section below, and use our issue tracker to report any issues or bugs you encounter.

The JetBrains Academy team

Rider and ReSharper 2025.3.0.4: Important Updates Released

Another set of updates for the 2025.3 versions of ReSharper and Rider has just been released. This release contains important bug-fixes as well as feature updates.

Let’s take a look at what’s been improved.

Rider 2025.3.0.4

Multi-agent experience in the AI Chat window: Junie and Claude Agent

Claude Agent has become the first third-party AI agent natively integrated into JetBrains IDEs. With its addition, JetBrains introduces a multi-agent experience that brings even more flexibility and power to your development workflow. Now that Claude Agent and Junie are available in the same chat interface, you can switch between agents seamlessly and get the right kind of assistance for every task.

The easiest way to start working with any agent now is to launch it directly from the AI chat. However, the Junie plugin (and some of its features exclusively) will still be available for you if you prefer to use Junie it this way.

Learn more here.

Transparent AI quota tracking in the IDE

You can now view your remaining AI credits, renewal date, and top-up balance directly inside your IDE, and if you run out of credits, you can initiate a top-up from there as well. This update makes it easier to monitor and manage your AI resources – bringing more clarity and convenience to your AI usage. 

In Junie, if your task uses more than 1.2 AI credits, you will get a notification. This feature is currently available in the Junie plugin and will be coming to the AI chat soon.

Learn more about AI quotas in this blog post.

[Coming Soon] Bring Your Own Key

With BYOK, you will be able to connect to OpenAI, Anthropic, or any OpenAI API-compatible local model using your own API key, without logging into JetBrains AI. This gives you more control over how you use AI in IntelliJ IDEA, and it’s ideal if you prefer to work with a specific provider.

This setup is particularly powerful when paired with a JetBrains AI subscription (including the free tier), which provides enhanced completion, extra models, and bonus credits while still allowing you to use your own key for chat and agents.

Learn more here. 

Game development

Rider now provides cloud-powered multi-line code completion for shaders in Unity, Unreal Engine, and Godot projects.For Godot developers, cloud completion suggestions are also available for GDScript files.

Working with databases

Rider replaces the term query console with query file – because consoles have essentially always been files, and it’s time the UI reflected that. We’ve also simplified the workflow, making it more discoverable and consistent. You can learn more about the change in this post. 

Notable fixes included in this build:

  • We’ve resolved the issue of excessive memory usage when opening .NET 6 solutions [RIDER-132952].
  • Rider now ships with the correct IJent version, restoring full WSL support. Git, Docker integration, terminals, and device discovery over WSL work reliably again. [IJPL-219668]
  • Deploying to Android devices now works reliably again. Rider correctly uploads the application APK file, even when a previous version is already installed on the device. [RIDER-132740]
  • Rendered documentation now correctly displays code containing < and > characters. [RIDER-119249]
  • Search Everywhere now returns results in a stable, predictable order. [RIDER-132113]
  • Source-generated files from System.Text.Json are now detected correctly and no longer produce false errors. [RIDER-132634]

For the complete list of resolved issues, please refer to our issue tracker. 

Download Rider 2025.3.0.4

ReSharper 2025.3.0.4 

Here are the most notable fixes included in this update:

  • SQL/NoSQL support can now be excluded from the dotUltimate installer. An installation key is available for silent setups, allowing teams to omit these features when not needed. [RSRP-501992]
  • The Unit Test Output panel in Out-of-Process mode now shows vertical scrollbars correctly, making long test output fully navigable again. [RSRP-501537]

For the full list of issues resolved in this build, please refer to our issue tracker.

Download ReSharper 2025.3.0.4


You can download the latest builds from our website (Rider, ReSharper) or via the Toolbox App. You can also update Rider as a snap.

Built-in Laravel Support: A New Era for PhpStorm Developers

For years, PhpStorm has been the go-to IDE for PHP developers – powerful and deeply integrated with the language. But there was one thing many kept asking for: Laravel support out of the box.

Starting with PhpStorm 2025.3, Laravel support is now built in. From the moment you open your project, everything just works – no plugins, no configuration, no extra steps.

Discover the story behind this update from PhpStorm Team Lead Roman Pronskiy, PhpStorm Software Developer Maria Filippova, JetBrains Product Lead Artemy Pestretsov, Laravel Idea plugin creator Adel Faizrakhmanov, Laravel creator Taylor Otwell, and JetBrains Developer Advocate for PHP Brent Roose:

Start your Laravel journey

FAQ

I use IntelliJ IDEA. How is Laravel support provided there?

In IntelliJ IDEA, you can install the Laravel Idea plugin as usual from the main menu: File | Settings | Plugins | Marketplace → “Laravel Idea”.

Will the standalone Laravel Idea plugin continue to be maintained?

Yes. Adel and the PhpStorm team will continue collaborating to ensure the plugin – and PhpStorm’s integrated support – remain the top-tier Laravel development experience in the industry.

Is Laravel support available if I’m using PhpStorm for free?

Yes. The built-in Laravel support is available to all PhpStorm users, including those using:

  • The 30-day free trial.
  • Early access builds.
  • Free licenses, such as licenses for students, teachers, open-source projects, or startups.

If you can run PhpStorm, you can use Laravel support – no limitations.

I use PhpStorm. Can I now uninstall the Laravel Idea plugin?

In PhpStorm, the Laravel Idea plugin now comes pre-installed and enabled, so you no longer have to download or manage it manually. However, you should keep the plugin enabled; disabling or removing it will turn off all Laravel-specific features.

Issue Center, All Reports Tab, Improved Report Sharing, the Ability to Change User Roles, and More in Datalore 2025.6

The final Datalore release of the year is here, and it brings multiple improvements designed to make your day-to-day work smoother. Whether you’re trying to keep reports error-free, managing user roles, or setting up environments, Datalore 2025.6 adds new tools that will help you stay organized and productive. 

Issue center

The issue center is available to help your teams monitor and resolve errors in published reports. 

Unlike notebooks, reports run code behind the scenes and hide technical details from viewers, so identifying and fixing issues in them can be difficult. The issue center tracks the errors from all reports in a workspace and displays them in one place, where you can search, filter, and resolve them with ease. Read more

Usages tab for databases

Database connections now include a Usages tab, where you can see all the notebooks and cells that rely on a particular connection. This makes it easier to understand where a connection is used, track dependencies, and quickly reuse or update code across your workspace. Read more

Option to change a user role to viewer

In Datalore On-Premises, you can now directly change someone’s role from user to viewer without having to delete the existing user account and then create a viewer from scratch. Because the licensing for Datalore On-Premises is based on the number of user seats, this streamlined role change can help you optimize license usage. Read more

We also improved the viewer UI to deliver a cleaner experience for those who can view notebooks and reports but don’t need to edit them.

All reports and Recents tabs

A new All reports tab on the home page allows you to access all the reports available to you, including those shared with you directly or via a workspace, as well as any publicly available reports that you have previously accessed. The Recents tab now includes recently opened reports in addition to notebooks.

Interactive report recalculation

When reports are opened, it’s crucial that they contain accurate data. Datalore users can configure whether report viewers are prompted to recalculate interactive reports on open, and instance administrators can select the default behavior in the Admin panel. 

We’ve added the option to recalculate all reports automatically, ensuring that viewers always see the most up-to-date results without requiring manual confirmation.

Ability to share individual reports from shared workspaces

You can now share individual reports without sharing the whole workspace or making the report public.

Automatic environment installation

We’ve added automatic environment installation for pip-based environments on machine start. When you specify an environment and Python version in the Admin panel, they will be installed as the machine boots. This feature uses uv as the package manager.

To learn more about all the updates, see the What’s new page in the Datalore documentation.

Upgrade to 2025.6