The International Conference on Software Engineering (ICSE) is the premier forum for presenting and discussing the most recent and significant technical research contributions in the field of Software Engineering. In the research track, we invite high-quality submissions of technical research papers describing original and unpublished results of software engineering research.

ICSE 2025 will follow a dual deadline structure introduced in 2024. In other words, submissions will occur in two cycles. Please refer to the section on Dual Submission Cycles in the following for the information.

NEW THIS YEAR #1: Due to the rapid growth of the area of “AI and Software Engineering”, it is now split into two: “AI for Software Engineering” and “Software Engineering for AI”. A new area “Architecture and Design” is introduced. The topics listed under each area have also been revised. Please see the “Research Areas” section below.

NEW THIS YEAR #2: We add back opportunities for “Author Response” in addition to “Revision” so that some potential misunderstandings can be clarified in the review process for papers that otherwise would be rejected. Also, for a paper receiving a “Revision” outcome, authors will be given an additional page of text in the revised paper to accommodate the required changes specified in the reviews.

NEW THIS YEAR #3: Submissions must follow the latest “IEEE Submission and Peer Review Policy” and “ACM Policy on Authorship” (with associated FAQ, which includes a policy regarding the use of generative AI tools and technologies, such as ChatGPT. After checking with the ICSE Steering Committee, we are piloting a human-in-the-loop automated process to identify AI-generated papers. A Review Process Co-Chair has volunteered to design and run this pilot process on submitted papers. To preserve confidentiality, when scanning submitted papers, the scripts will not make use of any third-party services.

NEW THIS YEAR #4: IEEE Transactions on Software Engineering, ACM Transactions on Software Engineering and Methodology and ICSE 2025, have received approval from the ICSE Steering Committee to launch the Sustainable Community Review Effort (SCRE) program, aimed at reducing community effort in reviewing journal extensions of conference papers and allowing authors to get faster and more consistent feedback. More information is available at: http://tinyurl.com/icse25-scre

NEW THIS YEAR #5: ICSE Steering Committee has recently approved a proposal for streamlining and enhancing the paper bidding and assignment process, aimed at reducing the workload of PC members and resulting in better assignments of papers. Two Review Process Co-Chairs have volunteered to help manage the updated bidding and assignment process. More information is available at: http://tinyurl.com/icse25-streamlining

Research Areas

ICSE welcomes submissions addressing topics across the full spectrum of Software Engineering, being inclusive of quantitative, qualitative, and mixed-methods research. Topics of interest include the following and are grouped into the following nine research areas. Please note that these topics are by no means exhaustive.

Each submission will need to indicate one of these nine areas as the chosen area. Optionally, the authors can consider adding an additional area. A paper may be moved from the chosen area(s) to another focus area at the discretion of the program chairs. Program chairs will ultimately assign a paper to an area chair, considering the authors’ selection, the paper’s content, and other factors such as (if applicable) possible conflicts of interest.

AI for Software Engineering

    AI-enabled recommender systems for automated SE (e.g., code generation, program repair, AIOps, software composition analysis, etc.)
    Human-centered AI for SE (e.g., how software engineers can synergistically work with AI agents)
    Trustworthy AI for SE (e.g., how to provide guarantees, characterize limits, and prevent misuse of AI for SE)
    Sustainable AI for SE (e.g., how to reduce energy footprint for greener AI for SE)
    Collaborative AI for SE (e.g., how AI agents collaborate for automating SE)
    Automating SE tasks with LLM and other foundation models (e.g., large vision model)
    Efficacy measurement beyond traditional metrics (e.g., accuracy, BLEU, etc.)
    Prompt engineering for SE (e.g., novel prompt design)
    AI-assisted software design and model driven engineering (e.g., specification mining, program synthesis, software architectural design)

Analytics

    Mining software repositories, including version control systems, issue tracking systems, software ecosystems, configurations, app stores, communication platforms, and novel software engineering data sources, to generate insights through various research methods
    Software visualization
    Data-driven user experience understanding and improvement
    Data driven decision making in software engineering
    Software metrics (and measurements)

Architecture and Design

    Architecture and design measurement and assessment
    Software design methodologies, principles, and strategies
    Theory building for/of software design
    Architecture quality attributes, such as security, privacy, performance, reliability
    Modularity and reusability
    Design and architecture modeling and analysis
    Architecture recovery
    Dependency and complexity analysis
    Distributed architectures, such as microservice, SOA, cloud computing
    Patterns and anti-patterns
    Technical debt in design and architecture
    Architecture refactoring
    Adaptive architectures
    Architecture knowledge management

Dependability and Security

    Formal methods and model checking (excluding solutions focusing solely on hardware)
    Reliability, availability, and safety
    Resilience and antifragility
    Confidentiality, integrity, privacy, and fairness
    Performance
    Design for dependability and security
    Vulnerability detection to enhance software security
    Dependability and security for embedded and cyber-physical systems

Evolution

    Evolution and maintenance
    API design and evolution
    Release engineering and DevOps
    Software reuse
    Refactoring and program differencing
    Program comprehension
    Reverse engineering
    Environments and software development tools
    Traceability to understand evolution

Human and Social Aspects

    Focusing on individuals (from program comprehension, workplace stress to job satisfaction and career progression)
    Focusing on teams (e.g., collocated, distributed, global, virtual; communication and collaboration within a team), communities (e.g., open source, communities of practice) and companies (organization, economics)
    Focusing on society (e.g., sustainability; diversity and inclusion)
    Focusing on programming languages, environments, and tools supporting individuals, teams, communities, and companies.
    Focusing on software development processes

Requirements and Modeling

    Requirements engineering (incl. non-functional requirements)
    Theoretical requirement foundations
    Requirements and architecture
    Feedback, user and requirements management
    Requirements traceability and dependencies
    Modeling and model-driven engineering
    Variability and product lines
    Systems and software traceability
    Modeling languages, techniques, and tools
    Empirical studies on the application of model-based engineering
    Model-based monitoring and analysis

Software Engineering for AI

    SE for AI models
    SE for systems with AI components
    SE for AI code, libraries, and datasets
    Engineering autonomic systems and self-healing systems
    Automated repair of AI models
    Testing and verification of AI-based systems
    Validation and user-based evaluation of AI-based systems
    Requirements engineering for AI-based systems

Testing and Analysis

    Software testing
    Automated test generation techniques such as fuzzing, search-based approaches, and symbolic execution
    Testing and analysis of non-functional properties
    GUI testing
    Mobile application testing
    Program analysis
    Program synthesis (e.g., constraint based techniques)
    Program repair
    Debugging and fault localization
    Runtime analysis and/or error recovery

Scope

Since the authors will choose an area for their submission, the scope of each area becomes important. Some submissions may relate to multiple areas. In such cases, the authors should choose the area for which their paper brings the maximum new insights. Moreover, authors also have the choice of indicating an alternate area for each paper.

Similarly, for certain papers. authors may have a question whether it belongs to any area, or is simply out of scope. For such cases, we recommend the authors to judge whether their paper brings new insights for software engineering. As an example, a formal methods paper with a focus on hardware verification may be deemed out of scope for ICSE. In general, papers that only peripherally concern software engineering and do not give new insights from the software engineering perspective would be less relevant to ICSE. Our goal is, however, to be descriptive, rather than prescriptive, to enable authors to make their own decisions about relevance.