Rigid body motion with non-conservative forces 👀

[cooperrc]

Rigid body motion with non-conservative forces

In this video, I build the Lagrange equations of motion for a pendulum that is damped at its support. In the Pluto notebook, I start to create the Symbolic equations of motion with the variational equations derived in the video.

Are you able to create a set of differential equations in Julia with this set up? Can we build a general solver that goes from:

1. L = T-V
2. eqs = $\frac{d}{dt}\left(\frac{\partial L}{\partial \dot{q}}\right) - \frac{\partial L}{\partial q} - F_q = 0$
3. ode_solver(eqs)

to plots and figures?

[danny-kruzick]

Yes, I was able to build this workflow in Julia.

In my notebook I built the Lagrangian, L=T−V, applied the Euler–Lagrange equations, converted those equations into a numerical ODE solver, then generated plots and figures from the solutions.

In my notebook, I defined the kinetic energy
𝑇, potential energy
𝑉, and then formed Lag = T - V. I also included the nonconservative generalized force term Qnc so the support damping could be added directly into the equations of motion. Then, for each generalized coordinate, I used the Euler–Lagrange expression

$$ \frac{d}{dt}\left(\frac{\partial L}{\partial \dot{q}_i}\right) - \frac{\partial L}{\partial q_i} = Q_i^{nc} $$

to generate the symbolic equations for both
𝑥 and 𝜃. After that, I turned the equations into a numerical ODE system and solved them in Julia.

The plots came out the way I would expect for a damped support pendulum. The displacement and angle both oscillate and decay back toward equilibrium.
The velocity plots show the same damping trend.

The phase portrait spirals inward, which is a good indicator of a stable damped system, and the energy plot shows the total energy decreasing over time, which makes sense because the damper is removing energy from the system.

[alw14027]

I found very similarly around 3/4 seconds the energy fully dissipates and pendulum stops. As I am still learning I looked to copy this on the optimal mass I found which looks to follow the same pattern.
NewLangrangianAttempt.pdf

[juliamachaj]

This is a great visualization of the Lagrangian method. These results also line up exactly with the decay you expect to see as the energy dissipates and it really shows how useful this method can be for various phsyical scenarios.

[cjdipietrantonio]

After watching the lecture, it was pretty clear that deriving EOMs for every generalized coordinate using the Euler-Lagrange method can be super tedious (especially for cases with a ton of generalized coordinates). So I decided to make a function that does it for me. The code below defines a function that takes the following inputs:

• Expressions for the kinetic and potential energy ($T$ and $V$)
• A vector of non-conservative forces $(\vec{F_q})$
• Vectors for generalized coordinates ($\vec{q}$) and their time derivatives $(\dot{\vec{q}})$
• A symbolic variable for time $(t)$
• A vector of symbolic parameters

The function uses the Euler-Lagrange equation to build a symbolic equation for each generalized coordinate. It then converts the 2nd-order equations into a 1st-order system, which is returned as an ODESystem struct, sys.

In the main driver, parameters for a physical system (the compound pendulum shown in the lecture) are defined and passed into the build_lagrangian_system() function as an example. The resulting sys struct is then passed to the ODEProblem() function along with the initial conditions and time span of the system. The result of this (prob struct) is then passed to the solve() function, which returns the sol struct. From this, the state-vector data can be accessed for plotting/further analysis. For this system, the following plot was created for proof of concept:

Which shows both $\theta$ and $x$ converging to equilibrium as energy is dissipated through the damper, as expected.

Overall, defining a function to automate the derivation of the EOMs for a system for us will save a significant amount of time and effort.

Code:

using Symbolics
using ModelingToolkit
using OrdinaryDiffEq
using Plots

# ------------------------------------------------------------------------
# Define Lagrangian System
# ------------------------------------------------------------------------

"""
    build_lagrangian_system(T, V, F_nc, q_vars, q_dots, t, params)

Automates derivation of EOMs for a physical system using Lagrangian Mechanics

# Arguments
- `T`: Symbolic expression for Kinetic Energy 
- `V`: Symbolic expression for Potential Energy
- `F_nc`: Vector of non-conservative forces
- `q_vars`: Vector of generalized coordinates
- `q_dots`: Vector of time derivatives of generalized coordinates
- `t`: time
- `params`: Vector of symbolic parameters

# Returns
- `sys`: ODESystem struct containing vector of 1st-order system of equations for each generalized coordinate and its time derivative (in addition to other objects)

"""

function build_lagrangian_system(T, V, F_nc, q_vars, q_dots, t, params)

    Lag = T - V 
    Dt = Differential(t)

    eqs = Equation[]
    for i in eachindex(q_vars)

        # Euler-Lagrange: d/dt(dL/dq_dot) - dL/dq = F_nc
        term1 = Dt(Symbolics.derivative(Lag, q_dots[i]))
        term2 = Symbolics.derivative(Lag, q_vars[i])

        # build symbolic equation
        push!(eqs, expand_derivatives(term1 - term2) ~ F_nc[i])
    end 

    @named sys = ODESystem(eqs, t, q_vars, params)
    return structural_simplify(sys)

end

# ------------------------------------------------------------------------
# Main Driver Function
# ------------------------------------------------------------------------

function main()

    # --------------------------------------------------------------------
    # Symbolic Variables and Parameters
    # --------------------------------------------------------------------

    @independent_variables t
    @variables x(t) θ(t)   
    @parameters m=0.4 L=1.0 g=9.81 k=0.1 b=0.2

    Dt = Differential(t)
    x_dot = Dt(x)
    θ_dot = Dt(θ)

    # --------------------------------------------------------------------
    # Kinematics & Energies
    # --------------------------------------------------------------------

    T = 0.5 * m * (x_dot^2 + (L^2 * θ_dot^2 / 3) + L * x_dot * θ_dot * cos(θ))
    V = 0.5 * k * x^2 + m * g * (L/2) * (1 - cos(θ))

    F_nc = [-b * x_dot, 0]
    q_vars = [x, θ]
    q_dots = [x_dot, θ_dot]
    params = [m, L, g, k, b]

    sys = build_lagrangian_system(T, V, F_nc, q_vars, q_dots, t, params)

    # --------------------------------------------------------------------
    # Initial Conditions
    # --------------------------------------------------------------------

    u0 = [
        x => 0.0,
        θ => 0.5,
        x_dot => 0.0,
        θ_dot => 0.0
    ]

    tspan = (0.0, 25.0)
    prob = ODEProblem(sys, u0, tspan)
    sol = solve(prob, Rodas5P())

    # --------------------------------------------------------------------
    # Plot Results
    # --------------------------------------------------------------------

    p = plot(sol, idxs=θ, ylabel="Amplitude", label="θ(t)", legend=:topleft)
    plot!(p, sol, idxs=x, label="x(t)")
    xlabel!(p, "Time (s)")

    display(p)
    savefig(p, "system_results.png")

end

# ------------------------------------------------------------------------
# Main Driver Call
# ------------------------------------------------------------------------

if abspath(PROGRAM_FILE) == @__FILE__
    main()
end

[jhngms]

This was very comprehensive, and useful in helping me understand the process start to finish. Your attached plot makes it evident that the system is damped.

thanks for this,
John

[queeps22-arch]

Yes, this workflow is definitely achievable in Julia, through the following steps outlined:

1. Define the Lagrangian symbolically by specifying kinetic energy (T) and potential energy (V), then forming L = T−V. Non-conservative forces like support damping can be included as separate terms.
2. Generate the equations of motion by applying the Euler-Lagrange equation to each generalized coordinate. This produces symbolic second-order ODEs.
3. Convert to a first-order ODE system and pass it to a numerical solver like ODEProblem() from DifferentialEquations.jl. The solution can then be plotted directly.

[Johnsw9]

this workflow is definitely doable in Julia. The notebook already lays out most of it; you define
𝑇 and 𝑉, form 𝐿=𝑇−𝑉, and then use the Euler–Lagrange equations to get the EOMs, adding damping as a non-conservative force. From there, you can convert the second-order equations into a first-order system and pass it into something like ODEProblem() to solve and plot.

I think the biggest advantage is how scalable it is. Once you set up a general function, you don’t have to manually derive equations every time, you can just plug in new systems and go straight from physics to simulation, which is way more efficient.

[JulianPojano]

Yes, this workflow is achievable in Julia, and I was able to implement it in my notebook.

I started by defining the kinetic energy T and potential energy V, then forming the Lagrangian, L=T−V. To account for the damping at the support, I included a nonconservative generalized force term $Q_{nc}$, allowing the dissipative effects to be incorporated directly into the equations of motion.

Next, I applied the Euler–Lagrange equation to each generalized coordinate:

$\frac{d}{dt}\left(\frac{\partial L}{\partial \dot{q}_i}\right) - \frac{\partial L}{\partial q_i} = Q_i^{nc}​$

This produced symbolic second-order differential equations (for example, in 𝑥 and
𝜃 for the pendulum system).

From there, I converted the system into first-order form so it could be used with a numerical solver. Using Julia’s DifferentialEquations.jl (via ODEProblem()), I defined and solved the system, then generated plots and figures directly from the solution.

Overall, this establishes a clear pipeline from defining L=T−V, to deriving equations of motion, to building a general ODE solver that produces numerical results and visualizations.

[alw14027]

@cjdipietrantonio I was able to take your code and manipulate it a little to find the optimal mass and best settling time. I found the following results:

Optimal Mass: 0.3 kg
Fastest Settling Time: 1.6259500546247232
Optimal Mass and Time.pdf

[joshuajimenez1]

Yes I was able to with this setup in Julia, which can automatically generate a full set of differential equations from a Lagrangian and then pass those equations directly into a general numerical solver that produces plots and figures. With the energies T and V, and the Lagrangian L=T−V, and applying the Euler–Lagrange formula, the code uses Symbolics and ModelingToolkit to derive the governing equations symbolically from the generalized coordinates x(t) and θ(t). These symbolic equations are then converted into an ODE system, simplified, and passed to a matrix compatible solver. Finally, the solution object integrates the system over time and can be visualized easily with Plots. Overall Julia is able to be used to handle the entire workflow from physics definition, to automatic equation generation, to numerical solution, to plotting.
dampedpdf.pdf

[vedantsingh28]

Yes, this workflow is achievable in Julia and the setup from the notebook already shows the main pieces needed to go from the physics definition to simulation and visualization. Starting from the kinematics shown in the screenshots, the generalized coordinates are q = [x, θ], and the position and velocity definitions allow us to form the kinetic and potential energies. From there we define the Lagrangian L = T − V, where the kinetic energy includes the coupling term between ẋ and θ̇ and the potential energy includes both the spring energy (1/2)kx² and the gravitational term mg(L/2)(1 − cosθ). Once the Lagrangian is defined symbolically (like in the Pluto notebook using Symbolics and ModelingToolkit), the Euler–Lagrange equations d/dt(∂L/∂q̇ᵢ) − ∂L/∂qᵢ = Fqᵢ can be applied to both x and θ. The damping at the support can be incorporated as a non-conservative generalized force (for example Fx = −b ẋ and Fθ = 0). This produces the coupled second-order differential equations like the ones shown in the symbolic outputs. From there, the next step is converting the second-order equations into a first-order system so they can be used with a numerical solver such as ODEProblem() from DifferentialEquations.jl. After defining the initial conditions, parameters, and time span, the solver generates a solution object that can be directly plotted. This creates a clean pipeline from defining T and V, to forming L = T − V, to automatically generating the equations of motion, to solving and plotting. Similar to what others observed, the results should show the expected damped behavior. The displacement x(t) and angle θ(t) both oscillate and decay toward equilibrium because the damper removes energy from the system. The phase portrait would spiral inward, which indicates a stable damped system, and the total energy should decrease over time, which makes sense physically since the damper dissipates energy. Overall, building a general function to automate the Euler–Lagrange derivation (like looping through the generalized coordinates and constructing the symbolic equations) makes this approach much more efficient. Instead of manually deriving equations for every new mechanical system, you can just define T, V, the generalized coordinates, and any non-conservative forces, then pass everything into a general solver to go directly from the physical model to numerical results and plots.

[shainaerrico]

Yes, it is possible to complete a workflow in Julia that takes you from the Lagrangian formulation all the way to numerical solutions and plots. Starting with the Lagrangian, L = T - V, symbolic differentiation using Symbolics.jl can automatically produce the Euler–Lagrange equations. Non-conservative effects, like damping, can be included as generalized forces.

Since these equations are typically second-order differential equations, they are converted into a system of first order ODEs by introducing velocity variables. ModelingToolkit.jl can then be used to simplify the system and transform them into an ODE system, making it compatible with numerical solvers.

Lastly, OrdinaryDiffEq.jl can solve the system to generate time histories and visualized using Plots.jl.

[bp-thibodeau]

I used VSCodes copliot Claude Sonnet model to generate a julia/pluto script to build a general solver. I've found that Claude is overall more capable than copliot when it comes to coding. Im curious if using claude directly (rather than copilot claude model) would give better performance. It had one very small error but was easily fixed! It seems like I'm getting the same results as everyone else:

[cooperrc]

Don't get too hung up on comparing AI models. There are minor differences, but if you're focused on the engineering+equations needed they will all converge to the same result.

I think of it like using different integration methods e.g. Euler vs Runge-Kutta. Both methods converge to the same result. Euler takes more integration steps, but at the end of the day it doesn't matter from the engineering+physics perspective.

Same thing will happen with AI models. You might need to refine the prompts an extra 2 times with one vs another, but if they are giving you vastly different answers, then there is something wrong with the fundamental engineering+physics.

[matlabkid]

I was able to create a set of differential equations in Julia with this set up, then build a general solver that goes from the 3 steps. The general code that builds this is 3 blocks in my code

Total cells before code starts: 4

Cell 5 of 8 — Build a symbolic system directly from the Euler–Lagrange equations

begin
@nAmed raw_sys = System(eqs_lagrange, t)
sys = mtkcompile(raw_sys)
end

Total cells before code starts: 5

Cell 6 of 8 — Initial conditions and time span

begin
u0 = [
x => 0.0,
θ => pi/3,
D(x) => 0.0,
D(θ) => 0.0
]
tspan = (0.0, 10.0)
end

Total cells before code starts: 6

Cell 7 of 8 — Generate and solve the ODE problem directly from the symbolic system

begin
prob = ODEProblem(sys, u0, tspan)
sol = solve(prob, Rosenbrock23())
end

I find it similar to MATLAB, and I used a similar method,R odas4, rather than Rosenbrock23 which did not work at first. Seems like when choosing these methods it is best for tolerance changes in accuracy.

09_damped-pendulum_discussionNPv3.html

[bgoncal22]

Yes, I think this setup can be turned into a general Julia solver. Starting from L=T−V, we can symbolically form the Euler–Lagrange equations, include damping as a generalized force, and then use "ModelingToolkit" plus "OrdinaryDiffEq" to solve the system numerically. Once the equations are packaged into an "ODESystem", the workflow naturally goes from symbolic mechanics to simulation and plotting. The damped pendulum support example is a good case because it shows how coupled equations in x(t) and θ(t) can be derived once and then solved for different parameter values. This can also be generalized into a reusable solver function where you define
T, V, the generalized coordinates q, and any non-conservative forces Fq, and then automatically generate the equations of motion, solve them, and plot the results.

[PeterLucido23]

It is definitely possible to build a general solver in Julia that moves from the Lagrangian (L = T - V) directly to a numerical solution. By using the Symbolics.jl and ModelingToolkit.jl packages, we can automate the derivation of the equations of motion (EOMs) which saves a lot of time compared to doing the 2nd-order calculus by hand.

For the damped pendulum on a sliding support, I defined the kinetic and potential energies and then formed the Lagrangian. The key is to include the non-conservative damping force (F_nc = -b * x_dot) on the right-hand side of the Euler-Lagrange equation:

ddt(dL/dq_dot) - dL/dq = F_nc

Define symbolic variables for t, x(t), theta(t) and parameters like m, L, g, k, b.

Use a loop to apply the Euler-Lagrange formula for each generalized coordinate.

Use the structural_simplify() function in ModelingToolkit to convert the 2nd-order symbolic equations into a 1st-order ODESystem.

Pass the system to ODEProblem() and use a solver like Rodas5P() or Rosenbrock23().

The resulting plots show exactly what you would expect for a damped system: the displacement x and the angle theta both oscillate and decay over time. Looking at the phase portrait, the inward spiral confirms that the energy is being dissipated by the support damper. This automated approach is much more scalable for complex systems where manual derivation becomes tedious.

[kristi-h-lee]

This setup can be implemented in Julia and it is possible to build a general solver that goes from a Lagrangian definition all the way to numerical solutions and plots. Working through this problem really helped me appreciate why automation is so useful for Lagrangian mechanics. Building a general function to handle the derivation made the process feel less intimidating. It allowed me to focus more on defining the physics correctly by choosing the right forces.

I also found that seeing the symbolic equations turn directly into a numerical solution made the connection between theory and simulation much clearer. Once the equations were converted into a first‑order ODE system and solved, the results matched the lecture: the oscillations decay over time and the system settles back to equilibrium due to damping. Overall, this workflow made Lagrangian mechanics feel more practical and scalable, especially for larger systems.

[NiFoley]

this is definitely achievable with Julia and similar to others I noticed most of the work was done in the notebook. the steps are defining T and V then inserting the damping term on the right side, applying Euler equations to convert into a differential equation then using an equation solver to find x(t) then convert x(t) into cyclindrical cordinates.

[Wesfrank54]

Yes, this can be created in Julia by forming the Lagrangian L=T−V and including damping as a non-conservative force to generate the equations of motion. These equations can then be converted into an ODE system and solved numerically to produce plots and visualizations.

The results behave as expected for a damped system: both x and θ oscillate and decay over time as energy is dissipated through the support. In some cases, x may not return to zero but instead settles at a nonzero equilibrium position, which reflects how the system balances under damping and restoring forces.

Overall, this workflow is efficient and scalable, allowing you to go directly from defining the physics to analyzing system behavior without manually deriving equations each time.

[smp21013]

Yes, this workflow is very feasible in Julia using the existing symbolic and numerical tooling: you can define the Lagrangian L=T−VL=T-VL=T−V symbolically, automatically form the Euler–Lagrange equations including non‑conservative generalized forces FqF_qFq​, and then pass the resulting differential equations directly to DifferentialEquations.jl for numerical solution. ModelingToolkit in particular is designed to go from symbolic system definition to generated ODE functions, which makes it possible to build a fairly general pipeline that starts from LLL, constructs d/dt(∂L/∂q˙)−∂L/∂q=Fq​, solves the equations, and produces plots using Plots.jl—all with minimal boilerplate and good performance.

[ericd3030]

For my creative plot, I wanted to move beyond just showing displacement or angle versus time and instead show what the system actually looks like as it moves. The earlier plots are useful because they quantify the motion: the sliding support oscillates back and forth, the pendulum angle decreases over time, and the total energy steadily drops because of damping. However, those plots are still somewhat abstract. The center of mass pendulum plot helps connect the math back to the physical system.

The creative figure shows several snapshots of the pendulum at different times during the simulation. Each line represents the bar position at a specific time, and the marker represents the center of mass of the bar. To create this plot, I used the solved values of x(t) and theta(t). The pin location moves horizontally with the support, while the bar angle determines where the end of the pendulum is located. This allowed me to reconstruct the geometry of the system at selected time steps.


The main result shown in the creative plot is that the pendulum does not simply rotate about a fixed point. Instead, the pivot point itself moves because it is connected to the spring-damper support. This creates a coupled motion between the horizontal translation of the support and the angular motion of the pendulum. At early times, the pendulum has a larger angle and the support displacement is more noticeable. As time increases, the damping removes energy from the system, so both the support motion and pendulum swing become smaller.

This plot was helpful because it visually confirmed the behavior seen in the other figures. The phase plot showed the motion spiraling inward, and the energy plot showed the system losing mechanical energy. The configuration snapshot plot shows the same idea physically: the system starts with a larger motion and gradually settles toward equilibrium. Overall, the creative plot made the simulation easier to interpret because it turned the differential equation results into a picture of the actual multibody motion.

[agambhir-uconn]

Cool plots Eric! I also visualized the different configurations of the pendulum with a slightly different method by showing the trace of the free end of the pendulum. I think your legend plot is more descriptive in showing how the position moves because of the legend.

[agambhir-uconn]

As others have discussed, it is not too complicated to create the differential equations for the damped pendulum and to setup a solver to evaluate the second order ODEs developed by computing the Lagrangian by using the function ODEProblem(). Julia makes it really easy to setup the system in terms of symbolic variables so you don’t have to go through a ton of effort deriving the equations if you’re messing around with the code (although it’s helpful to know what the equations are for debugging purposes). Others have posted some very intuitive plots of how the pendulum angle and support displacement are damped. I thought it would be interesting to visualize the spatial history of the pendulum. To that end, I developed this plot which shows the path--you can trace the path of the pendulum from an initial elevated position to its resting spot after a few oscillations.

[jaydawg-young]

I took inspiration from a fellow classmate and produced the above image. Overall, you can definitely built a solver. It was definitely very interesting to different initial conditions and to see the overall out put of the solver.

[POPandPiP]

[cbull0]

Yes a set of differential equations can be built into Julia with this set up. First you have to define the kinetic and potential energy to form the Lagrangian as L=T−V. Then use the Euler-Lagrange equation to each coordinate, with the damping added. Then, the equations can be converted into a first-order ODE system and solved and put into julia to graph it.

[tjs21014]

This discussion helped clarify the goals and expectations for the rotating pendulum project. It was useful to see how the system builds directly on the simple pendulum example but adds complexity through rotation, coupling, and non inertial effects. Identifying appropriate generalized coordinates early on seems especially important to keep the equations of motion manageable. I also appreciated the emphasis on using a Lagrangian approach rather than force balances, since it makes it easier to account for constraints and energy terms in a systematic way. It’s clear that visualizations and animations are important for validating the model and understanding how parameters like rotation rate affect stability and motion. Overall, this discussion made the project feel more approachable by framing it as a natural extension of what we’ve already done rather than an entirely new problem.

[gwgezas123]

here is what I were able to put together. it can definetly be put together as seen above

[GoateT33]

Yes, I was able to build this workflow in Julia and extend it beyond just solving the equations of motion.
In my notebook, I started from the Lagrangian formulation L=T−VL = T - VL=T−V, defined symbolically in Julia, and applied the Euler–Lagrange equations to generate the equations of motion. I included non‑conservative generalized forces so damping could be incorporated directly into the formulation rather than added afterward. Using Symbolics and ModelingToolkit, the resulting equations were automatically converted into a first‑order ODE system and solved numerically.
One thing I focused on was making the workflow generalized. Once the Lagrangian and generalized forces are defined, the same process can be reused for different systems without manually deriving equations each time. After solving the system, I generated standard time‑history plots for the generalized coordinates and velocities, which showed the expected oscillatory behavior with decay due to damping.
Overall, this approach made the connection between the analytical Lagrangian formulation and the physical interpretation very clear, and Julia handled the transition from symbolic equations to numerical simulation and visualization very smoothly.

[dugganjake]

I tried my own version of the damped pendulum / support system over time. I used generalized coordinates for the support displacement and pendulum angle, then added damping terms so the motion would slowly die out.

The graphs show exactly what I hoped they would. The support displacement and pendulum angle oscillate at first, but eventually come to a rest, with each amplitude getting smaller than the one before it. The phase plots showing a spiral instead of a closed loop proves the system doesn't conserve mechanical energy.

With no damping, the system would keep trading energy back and forth, and the motion would never stop or decrease at all.

[honczjoseph]

Julia is a great environment for building this scenario because it will connect the symbolic setup directly to the numerical solution process. Once we've defined the Lagrangian L = T - V and the non-conservative forces are included, the Euler-Lagrange equations can be generated symbolically then put into an ODE solver without needing to derive and rearrange by hand each time.
Something I found interesting was how the plots of damped systems such as these help to connect the equations to the physical behavior of the system. An example of this would be the pendulums angle and support motion both oscillating initially, but the amplitude of both will decrease gradually as damping dissipates the energy of the system. This makes it easier to see the non-conservative force that changes the long-term response of the system compared to an ideal undamped pendulum. The three graphs obtained using Julia show the relationship of the high oscilliation in pendulum angle and support position, as well as a graph showing how damping causes energy to decrease over time.

[HerminioV]

Yes, I was able to create the differential equations from the Lagrangian setup and solve them numerically. I converted the coupled second-order equations for the support motion and pendulum angle into a first-order ODE system, then used the solution to generate both time-response plots and phase plots.

The time plots show the support displacement, pendulum angle, support velocity, and angular velocity all oscillating while decaying due to the damping at the support. The phase plots also show this behavior clearly because the trajectories spiral inward instead of forming closed loops, which confirms that energy is being dissipated from the system over time. Overall, this shows that the process can go from L=T−V, to the equations of motion, to an ODE solver, and finally to useful plots that describe the system behavior.

[Coen-uc]

As many others have already demonstrated, it is possible to go from the Lagrangian to the Euler-Lagrange to the solved ODE, and then plot it.

I have found a tool in Julia called multibody that can provide plots and models of multibody systems without having to define the Euler-Lagrange or ODEs. Whether or not that helps develop an understanding or appreciation of advanced dynamics is for you to decide. Below is the link to the tutorial site if you are interested in building something with it. All you need to do is define the shapes of the bodies, their connections, and the initial conditions, and then Multibody can solve it for you.

https://help.juliahub.com/dyad/Multibody.jl/dev/

[HCastillo03]

Yes it is possible to create the solver and plot it. Going through the notebook I started with L = T - V, which then made the rest of the process feel more organized. Having the Lagrangian set, the Euler-Lagrange equations were formed quickly with Symbolics. Adding the damping term as a generalized force also made sense since the damping comes from the moving support.. After that, the equations can be passed into ModelingToolkit and turned into a first‑order ODE system, making them easy to solve with OrdinaryDiffEq. From there, plotting the results helps show how the base motion and pendulum angle are coupled and how both motions decay over time due to damping at the support.