Over the past decades, supercomputers have become increasingly complex, with a growing number of nodes, GPUs, CPUs, and levels of memory hierarchy, leading to ever more powerful platforms that, in 2026, exceed two quintillion floating-point operations per second. Fully exploiting these platforms is challenging. To avoid having to rewrite an application whenever the underlying hardware changes, runtime systems have been developed. They provide an abstraction of the machine, allowing users to focus primarily on application development, while low-level details such as memory management, driver initialization, and communications are handled automatically. Among existing runtime systems, many now rely on task-based programming, in which an application is divided into small units of work, called tasks. These tasks may depend on one another, thereby forming a Directed Acyclic Graph (DAG) that the runtime system can exploit. In particular, the Sequential Task Flow (STF) programming model makes it easy to express such DAGs by automatically constructing ependencies based on data accesses. However, STF, and more generally task-based programming models, face a major challenge: selecting the size of tasks, referred to as granularity. Indeed, these models require the granularity to be selected at task submission time in order to ensure consistent execution. Moreover, CPUs and GPUs require different task granularities to be used efficiently, meaning that a statically selected granularity can sometimes limit performance. To address this issue, modern runtime systems such as OpenMP, PaRSEC, OmpSs, StarPU, and IRIS extend the task model by introducing recursive tasks. At runtime, recursive tasks can either be executed as regular tasks or submit a sub-DAG of tasks. This enables the final execution to use a possibly finer granularity than the one selected at initial submission, thereby improving the dynamism of runtime systems. However, most runtime systems supporting recursive tasks leave the selection of the final granularity to the user, which reduces application portability. Indeed, each change in hardware generation may require the task granularity to be adjusted. This thesis addresses this issue by introducing several strategies to dynamically determine task granularity using the recursive task model. We propose different strategies to improve the utilization of both homogeneous and heterogeneous platforms. We also identify the adaptations required within runtime systems to enable dynamic and automatic task granularity selection using recursive tasks. Furthermore, we investigate how the recursive task model can help address issues arising from the use of the STF model in a distributed-memory context. Throughout this thesis, we use the recursive task model provided by the StarPU runtime system, and evaluate the performance of our strategies using the dense linear algebra library Chameleon on different platforms.